aconfig | Simple , useful and opinionated config loader | Configuration Management library

PKCS#1 Versus PKCS#8

Note that while private keys generated without pass phrases in PHP are PKCS#1, the private key generated from PHP with a pass phrase is actually PKCS#8 (see this link for how to determine which standard applies to a private key).

Third Party Library Required

In order to work with PEM-format keys, a custom JavaScript library (or other custom code) is required. There are various libraries at this link which you can look at. Many are not maintained anymore.

This example uses the Forge JavaScript library, but you could also use a different library.

Installing/Importing Forge

While there are various ways to build the Forge environment, the easiest is to add the following HTML code prior to where you need to do encryption/decryption:

have you checked this part:

This is an issue of using Erlang/OTP 23 and Elixir 1.9.4 simultaneously.

Elixir 1.9 is older than OTP 23, but elixir fully leverages OTP, so it relies on some warnings/messages coming from erlang compiler during compilation.

That said, downgrading OTP to the version Elixir 1.9 is aware of (21 would be fine, I believe,) or upgrading Elixir to the recent 1.11.1 would fix the issue producing fancy

You have four separate issues here.

If you use the -jar switch, the classpath is taken from the Class-Path manifest entry in the jar's manifest, and that is all that will happen - the -cp switch (and the CLASSPATH environment variable) are completely ignored. The solution is to fix your jarfile, which ought to have that classpath entry.

Separate from that issue, your -cp parameter is broken.

*.* in.. linux...? That's late 90s DOS, mate!

It's java doing the parsing of that *, which is unique, because in linux it's normally bash doing it, but that doesn't work here, because bash will be adding spaces, and java needs colons/semicolons, which is why java does it itself. The point is, java is rather limited and only understands a single *. Which bash will mess up. So, there is really only one way to do this.

• Single quotes.
• One star.

For example:

java -cp '.:./config/*' com.test.MainClass

Each individual entry in a classpath must be either:

• A directory which contains classfiles.
• A jar file

Note how it specifically cannot be 'a directory that contains jar files', and also cannot be 'a class file'; that is not a thing. The * is the usual treatment: It takes every file in the directory you padded with /* and considers them all to be part of the classpath.

So, if you write: java -cp ., that will not include app.jar. If you write java -cp './config/*', that will not include any class or config files hanging off of ./config (only jar files located there).

Including config files on the classpath is not how its done. You can, of course. This doesn't do anything whatsoever, unless you are using SomeClass.class.getResource or some other variant of getResource (those are no good, you should be using SomeClass.class.getResource or SomeClass.class.getResourceAsStream, but I digress), in which case, don't do that. Those aren't intended for config files, those are for static files (files that never change, such as, say, a 'save to cloud' icon for your swing user interface application). If you are doing that, you'd need to include ./config (and not './config/*') in your classpath, but it would be a better idea to fix your code.

config files should be in the user's home directory - System.getProperty("user.home"). You should consider the directory that contains the jar file(s) as the place where the executables live, and those are not necessarily editable by the user, and surely the point of a config file is that you can edit them. Hence why using the classpath for these is not how it is done.

I don't think you should work with Extensions here, or in general, any "raw-level" JUnit stuff (like lifecycle methods), because you won't be able to access the application context from them, won't be able to execute any custom logic on beans and so forth.

Instead, take a look at Spring's test execution listeners abstraction

With this approach, GreenMail will become a bean managed by spring (probably in a special configuration that will be loaded only in tests) but since it becomes a bean it will be able to load the property values and use @Value annotation.

In the test execution listener you'll start the server before the test and stop after the test (or the whole test class if you need that - it has "hooks" for that).

One side note, make sure you mergeMode = MergeMode.MERGE_WITH_DEFAULTS as a parameter to @TestExecutionListeners annotation, otherwise some default behaviour (like autowiring in tests, dirty context if you have it, etc) won't work.

Update 1

Following Update 1 in the question. This won't work because the listener itself is not a spring bean, hence you can't autowire or use @Value annotation in the listener itself. You can try to follow this SO thread that might be helpful, however originally I meant something different:

1. Make a GreenMail a bean by itself:

First of all, as of Hydra 1.0 - the defaults list is ONLY supported in the primary config. Below are two versions, the first version changes as little as possible in your example, and the second clean things up a bit.

Since you use PUBLIC keyword when link your library (A) with spdlog_header_only, CMake expects that this linking is also needed for users of your library. So, when you create config file for your library (with install(EXPORT)), CMake adds linking with spdlog_header_only target into the config file too. Like

You cannot create a new value to existing enum. But you can create a new type which is a superset of old enum and your extensions.

If you have the control over the call site, you could introduce some extensions like: Either[OriginalEnum, ExtensionsEnum] where you could make distinction between one set of values and the other and e.g. pass original ones where of you have extension, your could provide a separate behavior: