measurement-kit / libndt Goto Github PK

View Code? Open in Web Editor NEW

2.0 3.0 1.0 2.78 MB

Experimental ndt5 and ndt7 client engine written in C++11

Home Page: https://measurement-kit.github.io/

License: BSD 3-Clause "New" or "Revised" License

C++ 99.17% CMake 0.60% Shell 0.23%

network-speed network-measurement ndt7 ndt

libndt's Introduction

Measurement Kit

(deprecated) Network measurement engine

As of 2020-03-15, Measurement Kit is deprecated. This date has been chosen arbitrarily such that we could write:

Friends, OONItarians, developers, lend me your ears;
I come to bury Measurement Kit, not to praise it.
The bugs that software have live after them;
The good is oft interred with their remote branches;

And, of course, some good, old piece of art is also in order:

The rewrite of Measurement Kit in Go has been going on for quite some time now as ooni/probe-engine. As part of this rewrite, we considered all the use cases addressed by Measurement Kit, as documented by issue #1913.

We will most likely never release v0.11.0 of Measurement Kit. We will keep maintaining the 0.10.x version until 2021-03-14 (which is another interesting date). In the following, we'll discuss what options you have for replacing Measurement Kit in your use case. The current README reflects the situation "here and now". We are still working to provide a smooth upgrade path. Please, let us know if the upgrade path we have designed is troubling you by voting/contributing to the issues indicated below.

(The content of the old README.md is still available as OREADME.md.)

Changes in the settings JSON

The ooni/probe-engine implementation exposes similar APIs to Measurement Kit and specifically honours the data format of Measurement Kit v0.10.11. There should be no differences in the emitted events. There are however some differences in the settings as discussed below.

You should now add the following three keys to the settings JSON:

{
  "assets_dir": "",
  "state_dir": "",
  "temp_dir": ""
}

where assets_dir is the directory where to store assets, e.g. GeoIP databases; state_dir is the directory where to store the authentication information used with OONI orchestra; temp_dir is the directory where to store temporary files. If these three keys are not present, the test will fail during the startup phase (i.e. it will run for a very short time and you will see a bunch of failure.startup events emitted).

Also, the Go code does recognize all the settings recognized by Measurement Kit, but we have only implemented the settings required by OONI. All the other settings, when used, cause a failure during the experiment startup phase. If a not implemented setting is causing you issues, let us know by voting in the corresponding bug tracking issue.

Android

In your app/build.gradle file, replace

  implementation "org.openobservatory.measurement_kit:android-libs:$version"

with

  implementation "org.ooni:oonimkall:$version"

(The new package is called oonimkall because it's a OONI probe-engine based implementation of the mkall API for iOS. In turn, mkall means that we are bundling together all the MK APIs (i.e. the API for running experiments and all the ancillary APIs). For historical reasons android-libs was named before we defined the concept of mkall and was never renamed.)

The following differences apply between android-libs and oonimkall:

the import path is oonimkall and you can use it directly as a scope for the classes, rather than doing import oonimkall.Foo;
the MKAsyncTask class is replaced by oonimkall.Task and the MKAsyncTask.start factory is replaced by oonimkall.Oonimkall.startTask;
the MKGeoIPLookupResults and MKGeoIPLookupTask classes are replaced by oonimkall.GeoLookupResults and oonimkall.GeoLookupTask;
the MKOrchestraResults and MKOrchestraTask classes cannot be replaced, because it seems we are moving away from the orchestra model and, in going forward, we will only use orchestra internally inside of probe-engine to authenticate probes when they fetch input;
the MKReporterResults and MKReporterTask classes are replaced by oonimkall.CollectorResults and oonimkall.CollectorTask;
the MKResourcesManager class cannot be replaced, because the new code manages resources differently, by downloading them when needed into the assets_dir directory mentioned above;
the MKVersion class cannot be replaced because version pinning in Go makes it much simpler to know which version of what software we compile;
oonimkall throws Exception in much more cases than the code in android-libs that instead was using RuntimeException (using the latter was actually an anti-pattern and we are fixing it with the new code).

The following diff shows how to update code that runs an experiment, which is probably the most common use case of android-libs:

--- MK.java	2020-04-10 11:54:53.973521643 +0200
+++ PE.java	2020-04-10 11:55:50.915205613 +0200
@@ -1,10 +1,8 @@
 package com.example.something;
 
-import io.ooni.mk.MKAsyncTask;
-
 public class Example {
-    public static void run(settings String) {
-        MKAsyncTask task = MKAsyncTask.start(settings);
+    public static void run(settings String) throws Exception {
+        oonimkall.Task task = oonimkall.Oonimkall.startTask(settings);
         for (!task.isDone()) {
             String event = task.waitForNextEvent();
             System.out.println(event);

The most striking difference is that the function to start a task will explicitly throw Exception on failure. The old code would instead throw RuntimeException, as mentioned above. The required settings have slightly changed, as discussed above.

iOS

In your Podfile replace

    pod 'mkall', :git => 'https://github.com/measurement-kit/mkall-ios.git',
                 :tag => '$version'

with

    pod 'oonimkall', :podspec => 'https://dl.bintray.com/ooni/ios/oonimkall-$version.podspec'

The changes are similar to the ones described above for Android except that the oonimkall. prefix is Oonimkall for iOS. The following diff shows how you should be upgrading your MKAsyncTask code:

--- MK.m	2020-04-10 12:06:14.252573662 +0200
+++ PE.m	2020-04-10 12:08:18.520924676 +0200
@@ -1,11 +1,15 @@
 #import <Foundation/Foundation.h>
 
-#import <mkall/MKAsyncTask.h>
+#import <oonimkall/Oonimkall.h>
 
-void run(NSDictionary *settings) {
-    MKAsyncTask *task = [MKAsyncTask start:settings];
-    while (![task done]) {
-        NSDictionary *ev = [task waitForNextEvent];
+NSError *run(NSString *settings) {
+    NSError *error = nil;
+    OonimkallTask *task = OonimkallStartTask(settings, &error);
+    if (error != nil) {
+        return error;
+    }
+    while (![task isDone]) {
+        NSString *ev = [task waitForNextEvent];
         if (ev == nil) {
             continue;
         }

The most striking differences are the following. First, the function that starts a task now fails explicitly (e.g., if the settings are not valid JSON). Second, the new code takes in input and emits in output serialized JSONs rather than NSDictionary *. You are welcome to adapt code from MKAsyncTask to reimplement the previous behaviour. Also, remember that some extra mandatory settings are required, as described above.

Command Line

The miniooni binary mostly has the same CLI of the measurement_kit binary you could build from this repository. The following list describes the main differences between the two command line interfaces:

miniooni by default appends measurements to report.jsonl while measurement_kit uses a file name including the experiment name and the datetime when the experiment was started;
miniooni uses the -i, --input <input> flag to uniformly provide input for every experiment, while in measurement_kit different experiments use different command line flags after the experiment name (e.g., the -u <URL> flag is used by MK's Web Connectivity);
miniooni allows you to specify a proxy (e.g. Tor, Psiphon) with -P, --proxy <URL> that will be used for interacting with OONI services, but no such option exists in measurement_kit;
miniooni does not yet implement -s, --list that lists all the available experiments;
miniooni does not implement -l, --logfile <path> but you can use output redirection and tee to save logs anyway;
miniooni does not implement --ca-bundle-path <path>, --version, --geoip-country-path <path>, --geoip-asn-path <path>, because these resources are now downloaded and managed automatically;
miniooni does not implement --no-resolver-lookup;
miniooni writes state at $HOME/.miniooni.

We automatically build miniooni for windows/amd64, linux/amd64, and darwin/amd64 at every commit. The Linux build is static and does not depend on any external shared library. You can find the builds by looking into the GitHub actions of probe-engine and selecting for cli-windows, cli-linux, or cli-darwin. If you want us to attach such binaries to every release, please upvote the related issue.

Shared Library

The libooniffi package of ooni/probe-engine is a drop-in replacement for the Measurement Kit FFI API. The new API is defined by the ooniffi.h header. It is ABI compatible with MK's API. The only required change is to replace the mk_ prefix with ooniffi_. This diff shows the changes you typically need:

--- MK.c	2020-04-10 12:32:13.582783743 +0200
+++ PE.c	2020-04-10 12:32:36.633038633 +0200
@@ -1,19 +1,19 @@
 #include <stdio.h>
 
-#include <measurement_kit/ffi.h>
+#include <ooniffi.h>
 
 void run(const char *settings) {
-    mk_task_t *task = mk_task_start(settings);
+    ooniffi_task_t *task = ooniffi_task_start(settings);
     if (task == NULL) {
         return;
     }
-    while (!mk_task_is_done(task)) {
-        mk_event_t *event = mk_task_wait_for_next_event(task);
+    while (!ooniffi_task_is_done(task)) {
+        ooniffi_event_t *event = ooniffi_task_wait_for_next_event(task);
         if (event == NULL) {
             continue;
         }
-        printf("%s\n", mk_event_serialization(event));
-        mk_event_destroy(event);
+        printf("%s\n", ooniffi_event_serialization(event));
+        ooniffi_event_destroy(event);
     }
-    mk_task_destroy(task);
+    ooniffi_task_destroy(task);
 }

Of course, you also need to take into account the changes to the settings documented above.

You can generate your own builds with:

# macOS from macOS or Linux from Linux
go build -v -tags nomk -ldflags='-s -w' -buildmode c-shared -o libooniffi.so ./libooniffi
rm libooniffi.h  # not needed
cp libooniffi/ooniffi.h .  # use this header

# Windows from Linux or macOS with mingw-w64 installed
export CGO_ENABLED=1 GOOS=windows GOARCH=amd64 CC=x86_64-w64-mingw32-gcc
go build -v -tags nomk -ldflags='-s -w' -buildmode c-shared -o libooniffi.dll ./libooniffi
rm libooniffi.h  # not needed
cp libooniffi/ooniffi.h .  # use this header

Let us know if you want us to automatically publish libooniffi dynamic libraries by upvoting the related issue.

libndt's People

Contributors

Stargazers

Watchers

Forkers

robertodauria

libndt's Issues

Allow for more mlab-ns flexibility

We're querying multiple hosts but this is a habit from the times when mlab-ns was not polling hosts in the platform very often. Using a single host is actually fine and simplifies code.

Use locate.measurementlab.net/ndt7 when available

Soon the above URI will be available. We should use that for ndt7.

ndt5: validate version number?

cmake: make OpenSSL and cURL as requirements

This is evolving towards being a research client. Moreover, it seems that the default of not using TLS and not using mlab-ns is not desirable at all. Therefore, there's no point in keeping a more complex than needed CMakeLists.txt to support these options.

Doing this will enable doing #91 much more easily.

mlabns: make sure we set user agent

We should use CURLOPT_FAILONERROR

For additional correctness, we can use this flag when talking with mlabns.

example_client should probably be renamed simple_ndt_client

Write regress tests for TLS and websocket

Release v0.25.x does not include regress tests for TLS and websocket. This should be implemented so that we can be more sure about the code correctness and coverage.

ndt5: implement multi-stream upload?

The answer is probably "no". Yet, there's a TODO in the comment, so I'm tracking it.

Add codacy to CI checks

See libpull/libpull#75

ndt5: refactor incrementing active variable

Consider using CURL as a socket and TLS layer

It's possible to tell CURL to just connect to a URL and then stop. There is also a CURL API to obtain the connected descriptor and use it to read and write. This looks like a code simplification, because it allows us to avoid rolling out our socket code and our OpenSSL code. Also, using CURL as a TLS layer means we can use different libraries on different platforms. This would make libndt smaller on Desktop where we can use Windows own SSL on Windows, Darwin SSL on macOS. On mobile, we can use Darwin SSL on iOS. For Android, there's currently no SSL library in the NDK.

libndt requires OpenSSL v1.1+

So, we should either fail in CMake or, as an alternative, use macros like in https://github.com/libevent/libevent/blob/master/openssl-compat.h to make the code compile.

mingw: std::random_device is not random

We're using std::random_device, which is not random with MingGW. The proper fix may be to use OpenSSL to get some entropy to initialise the RNG. Otherwise we can do something similar to what is done by mkuuid4: https://github.com/measurement-kit/mkuuid4/blob/v0.1.0/mkuuid4.hpp#L118.

libndt: make Client methods private, unless needed by users

Use friend classes to enable unit tests.

Constants should be in internal namespace and/or in the .cpp file

Unless the constants are part of the public API

websocket: implement handshake with random data

We're currently using hardcoded values. This is a huge bummer because it means that we defy the purpose of a real WebSocket handshake (i.e. to avoid caching in the middle).

ndt7: use the production mlabns URL

libndt: Client NDTsettings should be private

Set it at construction time, and never again. Have a default no-arg constructor that uses the default initialization.

cppcheck libndt.hpp and minimise errors

Update dependencies to the latest version

Implement TLS

ndt7: warn if the user selects a non implemented subtest

There is a bunch of subtests that ndt7 will never implement. Warn if one of them is selected.

ndt5: report speed integral in the periodic callback

This issue has been reported by @mattmathis. It's rather confusing that we don't report the integral in the periodic callback. The reason why we're not doing it has to do with the original plan of integrating this library into Measurement Kit. Yet, since we're not going to do that, it stems that we don't need to do what MK does. The integral is much more useful for research and hence is highly preferable.

ndt5: allocate buffers using heap

We're currently using the stack and doing that breaks running on musl, where we cause stack overflow, since by default a thread only have 80 KiB of stack.

Make the settings object const

As I discussed #62 (comment), the settings object is using during log calls that may happen from different threads, and we should be safe because it's not modified. So, it should probably be made const. That will entail a little bit of refactoring but I feel that in general this kind of separation should be healthy.

ndt5/download: emit server computed speed

Consider refactoring to a single-include-header library

This will greatly simplify integration, not only with MK but in general with anyone. Telling people to include a header in the build looks like a trend in the post C++11 world.

README: document how to use libndt-client

Reported by @mattmathis.

libndt-client: implement `-batch` mode

Like ooni/probe-cli and m-lab/ndt7-client, we should have a batch mode where JSON messages are emitted either on the standard output or on the standard error.

When running in non-batch mode, the output should be more compact. When running in batch mode, we should use, if possible, the same JSON format of m-lab/ndt7-client.

ws: ignore text after 201

Currently the code assumes the server will send HTTP/1.1 201 Switching Protocols. We should instead perform a more robust parsing of the response.

README: Show usage, not implementation

Think of the readme from the perspective of a library user, not a library developer.

The bytes generator's different from original NDT

So, when running clear text tests, it can be possible to tell whether we're original NDT or libndt.

Maybe use subrepos instead of vendoring

Probably using a subrepo instead of vendoring more cleary communicates where a specific bit of code comes from. When can do that easily for most sources except strtonum.c. The latter however should not change much over time, hence it makes sense to really vendor it. Conversely, other pieces of code may change quite rapidly (especially nlohmann/json.hpp) so subrepo seems actually better.

libndt does not build on debian/arm

root@78e2e165a6f5:/libndt# cmake --build .
Scanning dependencies of target tests-curl
[ 14%] Building CXX object CMakeFiles/tests-curl.dir/curlx_test.cpp.o
In file included from /libndt/curlx_test.cpp:6:
/libndt/libndt.hpp: In member function 'bool measurement_kit::libndt::Client::ndt7_download()':
/libndt/libndt.hpp:1935:56: error: narrowing conversion of 'count' from 'measurement_kit::libndt::Size' {aka 'long long unsigned int'} to 'std::__cxx11::basic_string<char>::size_type' {aka 'unsigned int'} inside { } [-Werror=narrowing]
       std::string sinfo{(const char *)buff.get(), count};
                                                        ^
/libndt/libndt.hpp:1935:56: error: conversion from 'measurement_kit::libndt::Size' {aka 'long long unsigned int'} to 'std::__cxx11::basic_string<char>::size_type' {aka 'unsigned int'} may change value [-Werror=conversion]
In file included from /usr/include/c++/8/vector:64,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_vector.h: In member function 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = Catch::SectionEndInfo; _Alloc = std::allocator<Catch::SectionEndInfo>]':
/usr/include/c++/8/bits/stl_vector.h:1085:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> >' changed in GCC 7.1
    _M_realloc_insert(end(), __x);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_vector.h: In member function 'std::vector<_Tp, _Alloc>::reverse_iterator std::vector<_Tp, _Alloc>::rbegin() [with _Tp = Catch::SectionEndInfo; _Alloc = std::allocator<Catch::SectionEndInfo>]':
/usr/include/c++/8/bits/stl_vector.h:735:38: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> >' changed in GCC 7.1
       { return reverse_iterator(end()); }
                                      ^
/usr/include/c++/8/bits/stl_vector.h: In member function 'std::vector<_Tp, _Alloc>::reverse_iterator std::vector<_Tp, _Alloc>::rend() [with _Tp = Catch::SectionEndInfo; _Alloc = std::allocator<Catch::SectionEndInfo>]':
/usr/include/c++/8/bits/stl_vector.h:753:40: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> >' changed in GCC 7.1
       { return reverse_iterator(begin()); }
                                        ^
/usr/include/c++/8/bits/stl_vector.h: In member function 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/stl_vector.h:1085:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), __x);
    ^~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/map:61,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_map.h: In member function 'std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](std::map<_Key, _Tp, _Compare, _Alloc>::key_type&&) [with _Key = std::__cxx11::basic_string<char>; _Tp = nlohmann::basic_json<>; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_map.h:518:8: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
    __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {const Catch::SectionEndInfo&}; _Tp = Catch::SectionEndInfo; _Alloc = std::allocator<Catch::SectionEndInfo>]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<Catch::SectionEndInfo>::iterator' {aka '__gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> >'} changed in GCC 7.1
       vector<_Tp, _Alloc>::
       ^~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/bits/stl_algobase.h:67,
                 from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_iterator.h: In constructor 'std::reverse_iterator<_Iterator>::reverse_iterator(std::reverse_iterator<_Iterator>::iterator_type) [with _Iterator = __gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> >]':
/usr/include/c++/8/bits/stl_iterator.h:133:7: note: parameter passing for argument of type 'std::reverse_iterator<__gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> > >::iterator_type' {aka '__gnu_cxx::__normal_iterator<Catch::SectionEndInfo*, std::vector<Catch::SectionEndInfo> >'} changed in GCC 7.1
       reverse_iterator(iterator_type __x) : current(__x) { }
       ^~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/bits/stl_algobase.h:66,
                 from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_iterator_base_funcs.h: In function '_InputIterator std::next(_InputIterator, typename std::iterator_traits<_Iter>::difference_type) [with _InputIterator = std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_iterator_base_funcs.h:213:5: note: parameter passing for argument of type 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >' changed in GCC 7.1
     next(_InputIterator __x, typename
     ^~~~
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {const nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long int, long long unsigned int, double, std::allocator, nlohmann::adl_serializer>&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
       vector<_Tp, _Alloc>::
       ^~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/map:60,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_tree.h: In member function 'std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_emplace_hint_unique(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, _Args&& ...) [with _Args = {const std::piecewise_construct_t&, std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&>, std::tuple<>}; _Key = std::__cxx11::basic_string<char>; _Val = std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >; _KeyOfValue = std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_tree.h:2411:7: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
       _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::__uninitialized_move_if_noexcept_a(_InputIterator, _InputIterator, _ForwardIterator, _Allocator&) [with _InputIterator = Catch::SectionEndInfo*; _ForwardIterator = Catch::SectionEndInfo*; _Allocator = std::allocator<Catch::SectionEndInfo>]':
/usr/include/c++/8/bits/stl_uninitialized.h:311:2: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
       return std::__uninitialized_copy_a
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::__uninitialized_move_if_noexcept_a(_InputIterator, _InputIterator, _ForwardIterator, _Allocator&) [with _InputIterator = nlohmann::basic_json<>*; _ForwardIterator = nlohmann::basic_json<>*; _Allocator = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/stl_uninitialized.h:311:2: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
       return std::__uninitialized_copy_a
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~
  (_GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__first),
  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(__last), __result, __alloc);
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/map:60,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_tree.h: In member function 'std::pair<std::_Rb_tree_node_base*, std::_Rb_tree_node_base*> std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_get_insert_hint_unique_pos(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, const key_type&) [with _Key = std::__cxx11::basic_string<char>; _Val = std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >; _KeyOfValue = std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_tree.h:2146:5: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = std::move_iterator<Catch::SectionEndInfo*>; _ForwardIterator = Catch::SectionEndInfo*; _Tp = Catch::SectionEndInfo]':
/usr/include/c++/8/bits/stl_uninitialized.h:287:5: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
     __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
     ^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:287:5: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
/usr/include/c++/8/bits/stl_uninitialized.h:289:37: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
     { return std::uninitialized_copy(__first, __last, __result); }
              ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /libndt/curlx_test.cpp:5:
/libndt/json.hpp: In member function 'IteratorType nlohmann::basic_json<ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer>::erase(IteratorType) [with IteratorType = nlohmann::detail::iter_impl<nlohmann::basic_json<> >; typename std::enable_if<(std::is_same<InputIT, nlohmann::detail::iter_impl<nlohmann::basic_json<ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer> > >::value || std::is_same<InputIT, nlohmann::detail::iter_impl<const nlohmann::basic_json<ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer> > >::value), int>::type <anonymous> = 0; ObjectType = std::map; ArrayType = std::vector; StringType = std::__cxx11::basic_string<char>; BooleanType = bool; NumberIntegerType = long long int; NumberUnsignedType = long long unsigned int; NumberFloatType = double; AllocatorType = std::allocator; JSONSerializer = nlohmann::adl_serializer]':
/libndt/json.hpp:16040:45: note: parameter passing for argument of type 'std::map<std::__cxx11::basic_string<char>, nlohmann::basic_json<>, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::iterator' {aka 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
                 result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
/libndt/json.hpp:16046:44: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::const_iterator' {aka '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
                 result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
In file included from /usr/include/c++/8/map:61,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_map.h: In member function 'std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = std::__cxx11::basic_string<char>; _Tp = nlohmann::basic_json<>; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_map.h:499:8: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
    __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = std::move_iterator<nlohmann::basic_json<>*>; _ForwardIterator = nlohmann::basic_json<>*; _Tp = nlohmann::basic_json<>]':
/usr/include/c++/8/bits/stl_uninitialized.h:287:5: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
     __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
     ^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:287:5: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
/usr/include/c++/8/bits/stl_uninitialized.h:289:37: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
     { return std::uninitialized_copy(__first, __last, __result); }
              ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = std::move_iterator<Catch::SectionEndInfo*>; _ForwardIterator = Catch::SectionEndInfo*]':
/usr/include/c++/8/bits/stl_uninitialized.h:115:5: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
     uninitialized_copy(_InputIterator __first, _InputIterator __last,
     ^~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:115:5: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
/usr/include/c++/8/bits/stl_uninitialized.h:134:15: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
       return std::__uninitialized_copy<__is_trivial(_ValueType1)
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            && __is_trivial(_ValueType2)
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            && __assignable>::
            ~~~~~~~~~~~~~~~~~~
  __uninit_copy(__first, __last, __result);
  ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/map:61,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_map.h: In member function 'std::map<_Key, _Tp, _Compare, _Alloc>::iterator std::map<_Key, _Tp, _Compare, _Alloc>::erase(std::map<_Key, _Tp, _Compare, _Alloc>::iterator) [with _Key = std::__cxx11::basic_string<char>; _Tp = nlohmann::basic_json<>; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_map.h:1036:7: note: parameter passing for argument of type 'std::map<std::__cxx11::basic_string<char>, nlohmann::basic_json<>, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::iterator' {aka 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
       erase(iterator __position)
       ^~~~~
/usr/include/c++/8/bits/stl_map.h:1037:37: note: parameter passing for argument of type 'std::map<std::__cxx11::basic_string<char>, nlohmann::basic_json<>, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::iterator' {aka 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
       { return _M_t.erase(__position); }
                                     ^
In file included from /usr/include/c++/8/vector:64,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_vector.h: In member function 'std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::erase(std::vector<_Tp, _Alloc>::const_iterator) [with _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/stl_vector.h:1317:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::const_iterator' {aka '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
       erase(const_iterator __position)
       ^~~~~
/usr/include/c++/8/bits/stl_vector.h:1318:58: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
       { return _M_erase(begin() + (__position - cbegin())); }
                                                          ^
In file included from /usr/include/c++/8/map:60,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_tree.h: In member function 'std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_emplace_hint_unique(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator, _Args&& ...) [with _Args = {const std::piecewise_construct_t&, std::tuple<const std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&>, std::tuple<>}; _Key = std::__cxx11::basic_string<char>; _Val = std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >; _KeyOfValue = std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_tree.h:2411:7: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
       _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {nlohmann::detail::value_t}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {double&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {bool&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {std::nullptr_t}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {long long int&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {long long unsigned int&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = std::move_iterator<nlohmann::basic_json<>*>; _ForwardIterator = nlohmann::basic_json<>*]':
/usr/include/c++/8/bits/stl_uninitialized.h:115:5: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
     uninitialized_copy(_InputIterator __first, _InputIterator __last,
     ^~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:115:5: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
/usr/include/c++/8/bits/stl_uninitialized.h:134:15: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
       return std::__uninitialized_copy<__is_trivial(_ValueType1)
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            && __is_trivial(_ValueType2)
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            && __assignable>::
            ~~~~~~~~~~~~~~~~~~
  __uninit_copy(__first, __last, __result);
  ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h: In static member function 'static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = std::move_iterator<Catch::SectionEndInfo*>; _ForwardIterator = Catch::SectionEndInfo*; bool _TrivialValueTypes = false]':
/usr/include/c++/8/bits/stl_uninitialized.h:76:9: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
         __uninit_copy(_InputIterator __first, _InputIterator __last,
         ^~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:76:9: note: parameter passing for argument of type 'std::move_iterator<Catch::SectionEndInfo*>' changed in GCC 7.1
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::emplace_back(_Args&& ...) [with _Args = {nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long int, long long unsigned int, double, std::allocator, nlohmann::adl_serializer>}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:109:4: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    _M_realloc_insert(end(), std::forward<_Args>(__args)...);
    ^~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/map:60,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_tree.h: In member function 'std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::erase(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator) [with _Key = std::__cxx11::basic_string<char>; _Val = std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >; _KeyOfValue = std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_tree.h:1136:7: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::iterator' {aka 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
       erase(iterator __position)
       ^~~~~
/usr/include/c++/8/bits/stl_tree.h:1141:2: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
  _M_erase_aux(__position);
  ^~~~~~~~~~~~
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'std::vector<_Tp, _Alloc>::iterator std::vector<_Tp, _Alloc>::_M_erase(std::vector<_Tp, _Alloc>::iterator) [with _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:159:5: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
     vector<_Tp, _Alloc>::
     ^~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc:163:2: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
  _GLIBCXX_MOVE3(__position + 1, end(), __position);
  ^~~~~~~~~~~~~~
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {nlohmann::detail::value_t}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
       vector<_Tp, _Alloc>::
       ^~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {double&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {bool&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {std::nullptr_t}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {long long int&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {long long unsigned int&}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In static member function 'static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = std::move_iterator<nlohmann::basic_json<>*>; _ForwardIterator = nlohmann::basic_json<>*; bool _TrivialValueTypes = false]':
/usr/include/c++/8/bits/stl_uninitialized.h:76:9: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
         __uninit_copy(_InputIterator __first, _InputIterator __last,
         ^~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:76:9: note: parameter passing for argument of type 'std::move_iterator<nlohmann::basic_json<>*>' changed in GCC 7.1
In file included from /usr/include/c++/8/vector:69,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/vector.tcc: In member function 'void std::vector<_Tp, _Alloc>::_M_realloc_insert(std::vector<_Tp, _Alloc>::iterator, _Args&& ...) [with _Args = {nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool, long long int, long long unsigned int, double, std::allocator, nlohmann::adl_serializer>}; _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/vector.tcc:413:7: note: parameter passing for argument of type 'std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >::iterator' {aka '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >'} changed in GCC 7.1
       vector<_Tp, _Alloc>::
       ^~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/map:60,
                 from /libndt/json.hpp:54,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_tree.h: In member function 'void std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::_M_erase_aux(std::_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::const_iterator) [with _Key = std::__cxx11::basic_string<char>; _Val = std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >; _KeyOfValue = std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >; _Compare = std::less<std::__cxx11::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_tree.h:2486:5: note: parameter passing for argument of type 'std::_Rb_tree<std::__cxx11::basic_string<char>, std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> >, std::_Select1st<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >, std::less<std::__cxx11::basic_string<char> >, std::allocator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > > >::const_iterator' {aka 'std::_Rb_tree_const_iterator<std::pair<const std::__cxx11::basic_string<char>, nlohmann::basic_json<> > >'} changed in GCC 7.1
     _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_algobase.h: In function '_OI std::move(_II, _II, _OI) [with _II = __gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >; _OI = __gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >]':
/usr/include/c++/8/bits/stl_algobase.h:479:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     move(_II __first, _II __last, _OI __result)
     ^~~~
/usr/include/c++/8/bits/stl_algobase.h:479:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
/usr/include/c++/8/bits/stl_algobase.h:479:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
/usr/include/c++/8/bits/stl_algobase.h:487:39: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
       return std::__copy_move_a2<true>(std::__miter_base(__first),
              ~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
            std::__miter_base(__last), __result);
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/vector:64,
                 from /libndt/json.hpp:57,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_vector.h: In copy constructor 'std::vector<_Tp, _Alloc>::vector(const std::vector<_Tp, _Alloc>&) [with _Tp = nlohmann::basic_json<>; _Alloc = std::allocator<nlohmann::basic_json<> >]':
/usr/include/c++/8/bits/stl_vector.h:463:31: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
    std::__uninitialized_copy_a(__x.begin(), __x.end(),
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
           this->_M_impl._M_start,
           ~~~~~~~~~~~~~~~~~~~~~~~
           _M_get_Tp_allocator());
           ~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/bits/stl_algobase.h:61,
                 from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/cpp_type_traits.h: In function '_Iterator std::__miter_base(_Iterator) [with _Iterator = __gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >]':
/usr/include/c++/8/bits/cpp_type_traits.h:419:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     __miter_base(_Iterator __it)
     ^~~~~~~~~~~~
In file included from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_algobase.h: In function '_OI std::__copy_move_a2(_II, _II, _OI) [with bool _IsMove = true; _II = __gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >; _OI = __gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >]':
/usr/include/c++/8/bits/stl_algobase.h:420:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     __copy_move_a2(_II __first, _II __last, _OI __result)
     ^~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_algobase.h:420:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
/usr/include/c++/8/bits/stl_algobase.h:420:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::__uninitialized_copy_a(_InputIterator, _InputIterator, _ForwardIterator, std::allocator<_Tp>&) [with _InputIterator = __gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >; _ForwardIterator = nlohmann::basic_json<>*; _Tp = nlohmann::basic_json<>]':
/usr/include/c++/8/bits/stl_uninitialized.h:287:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
     ^~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:287:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
/usr/include/c++/8/bits/stl_uninitialized.h:289:37: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     { return std::uninitialized_copy(__first, __last, __result); }
              ~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/8/bits/stl_algobase.h:67,
                 from /usr/include/c++/8/algorithm:61,
                 from /libndt/json.hpp:37,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_iterator.h: In function '_Iterator std::__niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container>) [with _Iterator = nlohmann::basic_json<>*; _Container = std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > >]':
/usr/include/c++/8/bits/stl_iterator.h:987:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
     ^~~~~~~~~~~~
In file included from /usr/include/c++/8/memory:65,
                 from /libndt/json.hpp:55,
                 from /libndt/curlx_test.cpp:5:
/usr/include/c++/8/bits/stl_uninitialized.h: In function '_ForwardIterator std::uninitialized_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >; _ForwardIterator = nlohmann::basic_json<>*]':
/usr/include/c++/8/bits/stl_uninitialized.h:115:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
     uninitialized_copy(_InputIterator __first, _InputIterator __last,
     ^~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:115:5: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
/usr/include/c++/8/bits/stl_uninitialized.h:134:15: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
       return std::__uninitialized_copy<__is_trivial(_ValueType1)
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            && __is_trivial(_ValueType2)
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            && __assignable>::
            ~~~~~~~~~~~~~~~~~~
  __uninit_copy(__first, __last, __result);
  ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h: In static member function 'static _ForwardIterator std::__uninitialized_copy<_TrivialValueTypes>::__uninit_copy(_InputIterator, _InputIterator, _ForwardIterator) [with _InputIterator = __gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >; _ForwardIterator = nlohmann::basic_json<>*; bool _TrivialValueTypes = false]':
/usr/include/c++/8/bits/stl_uninitialized.h:76:9: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
         __uninit_copy(_InputIterator __first, _InputIterator __last,
         ^~~~~~~~~~~~~
/usr/include/c++/8/bits/stl_uninitialized.h:76:9: note: parameter passing for argument of type '__gnu_cxx::__normal_iterator<const nlohmann::basic_json<>*, std::vector<nlohmann::basic_json<>, std::allocator<nlohmann::basic_json<> > > >' changed in GCC 7.1
cc1plus: all warnings being treated as errors
make[2]: *** [CMakeFiles/tests-curl.dir/build.make:63: CMakeFiles/tests-curl.dir/curlx_test.cpp.o] Error 1
make[1]: *** [CMakeFiles/Makefile2:73: CMakeFiles/tests-curl.dir/all] Error 2
make: *** [Makefile:141: all] Error 2

ndt7: decide what to do when first host fails

libndt: make ndt7 the default

protocol types: should actually be a set of flags

json/not json
ws/not ws
tls/not tls

Make ndt7 (if available) the default

Currently the default is unencrypted and this is a bummer because we should actually use as default the most modern configuration available, rather than the other way round.

Remove mutex used only during log calls

There is no shared resource to be protected by that mutex. In general putting the mutex and the resource together strikes me as more obvious. Discussed in #62 (comment) with @pboothe.

Add support for ndt7

The current code already contains most of the functionality required to implement ndt7. What is needed is to enhance the WebSocket negotiation and to implement the protocol.

Implement WebSockets

With @pboothe we examined different solutions and we concluded that it might be a good idea to check whether the already existing WebSockets code in NDT could be easily adapted for the client side. The main advantages of importing such code bases would that (1) it is already tailored to NDT needs and (2) it is very well tested covering a wide range of inputs and failure cases.

References:

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.