├── README.md ├── arduino ├── .DS_Store ├── BlinkerIR │ ├── .DS_Store │ ├── BlinkerIR.ino │ ├── README.md │ └── images │ │ ├── blinkerir1.png │ │ ├── blinkerir2.png │ │ ├── blinkerir3.png │ │ ├── blinkerir4.png │ │ └── blinkerir5.png ├── blinker_NodeMcu_mi_duer_aligenie_IR_control │ ├── .DS_Store │ ├── blinker_NodeMcu_mi_duer_aligenie_IR_control.ino │ └── blinker_NodeMcu_mi_duer_aligenie_IR_control.ino.nodemcu.bin ├── blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch │ ├── .DS_Store │ ├── blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino │ ├── blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino.generic_0.bin │ └── blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino.generic_1.bin ├── blinker_led_Aligenie_shuangkai │ ├── .DS_Store │ ├── blinker_led_Aligenie_shuangkai.ino │ └── blinker_led_Aligenie_shuangkai.ino.nodemcu.bin ├── blinker_mi_dur_ali_button_4_dht_warn_wificfg │ ├── .DS_Store │ ├── blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino │ ├── blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino.nodemcu_点动模式.bin │ └── blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino.nodemcu_自锁模式.bin ├── esp8266FansClock │ ├── README.md │ └── esp8266FansClock.ino ├── esp8266http-example │ ├── .DS_Store │ ├── README.md │ └── esp8266http-example.ino ├── images │ ├── blinkerir1.png │ ├── blinkerir2.png │ ├── blinkerir3.png │ ├── blinkerir4.png │ └── blinkerir5.png ├── libraries │ ├── .DS_Store │ ├── Adafruit_ESP8266 │ │ ├── .DS_Store │ │ ├── Adafruit_ESP8266.cpp │ │ ├── Adafruit_ESP8266.h │ │ ├── README.md │ │ ├── examples │ │ │ ├── .DS_Store │ │ │ └── webclient │ │ │ │ └── webclient.ino │ │ ├── library.properties │ │ └── previous │ │ │ └── Adafruit_ESP8266.ino │ ├── Adafruit_SSD1306 │ │ ├── Adafruit_SSD1306.cpp │ │ ├── Adafruit_SSD1306.h │ │ ├── README.md │ │ ├── examples │ │ │ ├── OLED_featherwing │ │ │ │ └── OLED_featherwing.ino │ │ │ ├── ssd1306_128x32_i2c │ │ │ │ └── ssd1306_128x32_i2c.ino │ │ │ ├── ssd1306_128x32_spi │ │ │ │ └── ssd1306_128x32_spi.ino │ │ │ ├── ssd1306_128x64_i2c │ │ │ │ └── ssd1306_128x64_i2c.ino │ │ │ └── ssd1306_128x64_spi │ │ │ │ └── ssd1306_128x64_spi.ino │ │ ├── library.properties │ │ ├── license.txt │ │ ├── scripts │ │ │ ├── Makefile │ │ │ ├── make_splash.py │ │ │ ├── splash1.png │ │ │ └── splash2.png │ │ └── splash.h │ ├── ArduinoJson │ │ ├── ArduinoJson.h │ │ ├── CHANGELOG.md │ │ ├── CMakeLists.txt │ │ ├── CONTRIBUTING.md │ │ ├── LICENSE.md │ │ ├── README.md │ │ ├── SUPPORT.md │ │ ├── appveyor.yml │ │ ├── banner.svg │ │ ├── component.mk │ │ ├── examples │ │ │ ├── JsonConfigFile │ │ │ │ └── JsonConfigFile.ino │ │ │ ├── JsonFilterExample │ │ │ │ └── JsonFilterExample.ino │ │ │ ├── JsonGeneratorExample │ │ │ │ └── JsonGeneratorExample.ino │ │ │ ├── JsonHttpClient │ │ │ │ └── JsonHttpClient.ino │ │ │ ├── JsonParserExample │ │ │ │ └── JsonParserExample.ino │ │ │ ├── JsonServer │ │ │ │ └── JsonServer.ino │ │ │ ├── JsonUdpBeacon │ │ │ │ └── JsonUdpBeacon.ino │ │ │ ├── MsgPackParser │ │ │ │ └── MsgPackParser.ino │ │ │ ├── ProgmemExample │ │ │ │ └── ProgmemExample.ino │ │ │ └── StringExample │ │ │ │ └── StringExample.ino │ │ ├── extras │ │ │ ├── ArduinoJsonConfig.cmake.in │ │ │ ├── CompileOptions.cmake │ │ │ ├── ci │ │ │ │ ├── arduino.sh │ │ │ │ ├── build.sh │ │ │ │ ├── coverage.sh │ │ │ │ ├── fuzz.sh │ │ │ │ ├── platformio.sh │ │ │ │ └── test.sh │ │ │ ├── fuzzing │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Makefile │ │ │ │ ├── json_fuzzer.cpp │ │ │ │ ├── json_seed_corpus │ │ │ │ │ ├── Comments.json │ │ │ │ │ ├── EmptyArray.json │ │ │ │ │ ├── EmptyObject.json │ │ │ │ │ ├── ExcessiveNesting.json │ │ │ │ │ ├── IntegerOverflow.json │ │ │ │ │ ├── Numbers.json │ │ │ │ │ ├── OpenWeatherMap.json │ │ │ │ │ ├── Strings.json │ │ │ │ │ └── WeatherUnderground.json │ │ │ │ ├── msgpack_fuzzer.cpp │ │ │ │ ├── msgpack_seed_corpus │ │ │ │ │ ├── array16 │ │ │ │ │ ├── array32 │ │ │ │ │ ├── false │ │ │ │ │ ├── fixarray │ │ │ │ │ ├── fixint_negative │ │ │ │ │ ├── fixint_positive │ │ │ │ │ ├── fixmap │ │ │ │ │ ├── fixstr │ │ │ │ │ ├── float32 │ │ │ │ │ ├── float64 │ │ │ │ │ ├── int16 │ │ │ │ │ ├── int32 │ │ │ │ │ ├── int64 │ │ │ │ │ ├── int8 │ │ │ │ │ ├── map16 │ │ │ │ │ ├── map32 │ │ │ │ │ ├── nil │ │ │ │ │ ├── str16 │ │ │ │ │ ├── str32 │ │ │ │ │ ├── str8 │ │ │ │ │ ├── true │ │ │ │ │ ├── uint16 │ │ │ │ │ ├── uint32 │ │ │ │ │ ├── uint64 │ │ │ │ │ └── uint8 │ │ │ │ └── reproducer.cpp │ │ │ ├── scripts │ │ │ │ ├── build-arduino-package.sh │ │ │ │ ├── build-single-header.sh │ │ │ │ ├── publish-particle-library.sh │ │ │ │ ├── publish.sh │ │ │ │ └── wandbox │ │ │ │ │ ├── JsonGeneratorExample.cpp │ │ │ │ │ ├── JsonParserExample.cpp │ │ │ │ │ ├── MsgPackParserExample.cpp │ │ │ │ │ └── publish.sh │ │ │ └── tests │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── ElementProxy │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── add.cpp │ │ │ │ ├── clear.cpp │ │ │ │ ├── compare.cpp │ │ │ │ ├── remove.cpp │ │ │ │ ├── set.cpp │ │ │ │ ├── size.cpp │ │ │ │ └── subscript.cpp │ │ │ │ ├── FailingBuilds │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── Issue1189.cpp │ │ │ │ ├── Issue978.cpp │ │ │ │ ├── read_long_long.cpp │ │ │ │ └── write_long_long.cpp │ │ │ │ ├── Helpers │ │ │ │ ├── CustomReader.hpp │ │ │ │ ├── Stream.h │ │ │ │ ├── WString.h │ │ │ │ └── progmem_emulation.hpp │ │ │ │ ├── IntegrationTests │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── gbathree.cpp │ │ │ │ ├── issue772.cpp │ │ │ │ ├── openweathermap.cpp │ │ │ │ └── round_trip.cpp │ │ │ │ ├── JsonArray │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── add.cpp │ │ │ │ ├── copyArray.cpp │ │ │ │ ├── createNested.cpp │ │ │ │ ├── equals.cpp │ │ │ │ ├── get.cpp │ │ │ │ ├── isNull.cpp │ │ │ │ ├── iterator.cpp │ │ │ │ ├── memoryUsage.cpp │ │ │ │ ├── nesting.cpp │ │ │ │ ├── remove.cpp │ │ │ │ ├── size.cpp │ │ │ │ ├── std_string.cpp │ │ │ │ ├── subscript.cpp │ │ │ │ └── undefined.cpp │ │ │ │ ├── JsonDeserializer │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── DeserializationError.cpp │ │ │ │ ├── array.cpp │ │ │ │ ├── array_static.cpp │ │ │ │ ├── filter.cpp │ │ │ │ ├── incomplete_input.cpp │ │ │ │ ├── input_types.cpp │ │ │ │ ├── invalid_input.cpp │ │ │ │ ├── misc.cpp │ │ │ │ ├── nestingLimit.cpp │ │ │ │ ├── number.cpp │ │ │ │ ├── object.cpp │ │ │ │ ├── object_static.cpp │ │ │ │ └── string.cpp │ │ │ │ ├── JsonDocument │ │ │ │ ├── BasicJsonDocument.cpp │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── DynamicJsonDocument.cpp │ │ │ │ ├── StaticJsonDocument.cpp │ │ │ │ ├── add.cpp │ │ │ │ ├── compare.cpp │ │ │ │ ├── containsKey.cpp │ │ │ │ ├── createNested.cpp │ │ │ │ ├── isNull.cpp │ │ │ │ ├── nesting.cpp │ │ │ │ ├── remove.cpp │ │ │ │ ├── shrinkToFit.cpp │ │ │ │ ├── size.cpp │ │ │ │ └── subscript.cpp │ │ │ │ ├── JsonObject │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── containsKey.cpp │ │ │ │ ├── copy.cpp │ │ │ │ ├── createNestedArray.cpp │ │ │ │ ├── createNestedObject.cpp │ │ │ │ ├── equals.cpp │ │ │ │ ├── invalid.cpp │ │ │ │ ├── isNull.cpp │ │ │ │ ├── iterator.cpp │ │ │ │ ├── memoryUsage.cpp │ │ │ │ ├── nesting.cpp │ │ │ │ ├── remove.cpp │ │ │ │ ├── size.cpp │ │ │ │ ├── std_string.cpp │ │ │ │ └── subscript.cpp │ │ │ │ ├── JsonSerializer │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── CustomWriter.cpp │ │ │ │ ├── JsonArray.cpp │ │ │ │ ├── JsonArrayPretty.cpp │ │ │ │ ├── JsonObject.cpp │ │ │ │ ├── JsonObjectPretty.cpp │ │ │ │ ├── JsonVariant.cpp │ │ │ │ ├── misc.cpp │ │ │ │ ├── std_stream.cpp │ │ │ │ └── std_string.cpp │ │ │ │ ├── JsonVariant │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── add.cpp │ │ │ │ ├── as.cpp │ │ │ │ ├── clear.cpp │ │ │ │ ├── compare.cpp │ │ │ │ ├── containsKey.cpp │ │ │ │ ├── copy.cpp │ │ │ │ ├── createNested.cpp │ │ │ │ ├── is.cpp │ │ │ │ ├── isnull.cpp │ │ │ │ ├── memoryUsage.cpp │ │ │ │ ├── misc.cpp │ │ │ │ ├── nesting.cpp │ │ │ │ ├── or.cpp │ │ │ │ ├── overflow.cpp │ │ │ │ ├── remove.cpp │ │ │ │ ├── set.cpp │ │ │ │ ├── subscript.cpp │ │ │ │ ├── types.cpp │ │ │ │ └── undefined.cpp │ │ │ │ ├── MemberProxy │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── add.cpp │ │ │ │ ├── clear.cpp │ │ │ │ ├── compare.cpp │ │ │ │ ├── containsKey.cpp │ │ │ │ ├── remove.cpp │ │ │ │ ├── set.cpp │ │ │ │ ├── size.cpp │ │ │ │ └── subscript.cpp │ │ │ │ ├── MemoryPool │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── StringCopier.cpp │ │ │ │ ├── allocVariant.cpp │ │ │ │ ├── clear.cpp │ │ │ │ ├── saveString.cpp │ │ │ │ └── size.cpp │ │ │ │ ├── Misc │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── FloatParts.cpp │ │ │ │ ├── JsonString.cpp │ │ │ │ ├── Readers.cpp │ │ │ │ ├── StringAdapters.cpp │ │ │ │ ├── StringWriter.cpp │ │ │ │ ├── TypeTraits.cpp │ │ │ │ ├── Utf16.cpp │ │ │ │ ├── Utf8.cpp │ │ │ │ ├── arithmeticCompare.cpp │ │ │ │ ├── conflicts.cpp │ │ │ │ ├── custom_string.hpp │ │ │ │ ├── unsigned_char.cpp │ │ │ │ ├── version.cpp │ │ │ │ └── weird_strcmp.hpp │ │ │ │ ├── MixedConfiguration │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── cpp11.cpp │ │ │ │ ├── decode_unicode_0.cpp │ │ │ │ ├── decode_unicode_1.cpp │ │ │ │ ├── enable_alignment_0.cpp │ │ │ │ ├── enable_alignment_1.cpp │ │ │ │ ├── enable_comments_0.cpp │ │ │ │ ├── enable_comments_1.cpp │ │ │ │ ├── enable_infinity_0.cpp │ │ │ │ ├── enable_infinity_1.cpp │ │ │ │ ├── enable_nan_0.cpp │ │ │ │ ├── enable_nan_1.cpp │ │ │ │ ├── enable_progmem_1.cpp │ │ │ │ ├── enable_string_deduplication_0.cpp │ │ │ │ ├── enable_string_deduplication_1.cpp │ │ │ │ ├── use_double_0.cpp │ │ │ │ ├── use_double_1.cpp │ │ │ │ ├── use_long_long_0.cpp │ │ │ │ └── use_long_long_1.cpp │ │ │ │ ├── MsgPackDeserializer │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── deserializeArray.cpp │ │ │ │ ├── deserializeObject.cpp │ │ │ │ ├── deserializeStaticVariant.cpp │ │ │ │ ├── deserializeVariant.cpp │ │ │ │ ├── doubleToFloat.cpp │ │ │ │ ├── incompleteInput.cpp │ │ │ │ ├── input_types.cpp │ │ │ │ ├── nestingLimit.cpp │ │ │ │ └── notSupported.cpp │ │ │ │ ├── MsgPackSerializer │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── destination_types.cpp │ │ │ │ ├── measure.cpp │ │ │ │ ├── misc.cpp │ │ │ │ ├── serializeArray.cpp │ │ │ │ ├── serializeObject.cpp │ │ │ │ └── serializeVariant.cpp │ │ │ │ ├── Numbers │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── parseFloat.cpp │ │ │ │ ├── parseInteger.cpp │ │ │ │ └── parseNumber.cpp │ │ │ │ ├── TextFormatter │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── writeFloat.cpp │ │ │ │ └── writeString.cpp │ │ │ │ └── catch │ │ │ │ ├── CMakeLists.txt │ │ │ │ ├── catch.cpp │ │ │ │ └── catch.hpp │ │ ├── keywords.txt │ │ ├── library.json │ │ ├── library.properties │ │ └── src │ │ │ ├── ArduinoJson.h │ │ │ ├── ArduinoJson.hpp │ │ │ ├── ArduinoJson │ │ │ ├── Array │ │ │ │ ├── ArrayFunctions.hpp │ │ │ │ ├── ArrayImpl.hpp │ │ │ │ ├── ArrayIterator.hpp │ │ │ │ ├── ArrayRef.hpp │ │ │ │ ├── ArrayShortcuts.hpp │ │ │ │ ├── ElementProxy.hpp │ │ │ │ └── Utilities.hpp │ │ │ ├── Collection │ │ │ │ ├── CollectionData.hpp │ │ │ │ └── CollectionImpl.hpp │ │ │ ├── Configuration.hpp │ │ │ ├── Deserialization │ │ │ │ ├── DeserializationError.hpp │ │ │ │ ├── Filter.hpp │ │ │ │ ├── NestingLimit.hpp │ │ │ │ ├── Reader.hpp │ │ │ │ ├── Readers │ │ │ │ │ ├── ArduinoStreamReader.hpp │ │ │ │ │ ├── ArduinoStringReader.hpp │ │ │ │ │ ├── FlashReader.hpp │ │ │ │ │ ├── IteratorReader.hpp │ │ │ │ │ ├── RamReader.hpp │ │ │ │ │ ├── StdStreamReader.hpp │ │ │ │ │ └── VariantReader.hpp │ │ │ │ └── deserialize.hpp │ │ │ ├── Document │ │ │ │ ├── BasicJsonDocument.hpp │ │ │ │ ├── DynamicJsonDocument.hpp │ │ │ │ ├── JsonDocument.hpp │ │ │ │ └── StaticJsonDocument.hpp │ │ │ ├── Json │ │ │ │ ├── EscapeSequence.hpp │ │ │ │ ├── JsonDeserializer.hpp │ │ │ │ ├── JsonSerializer.hpp │ │ │ │ ├── Latch.hpp │ │ │ │ ├── PrettyJsonSerializer.hpp │ │ │ │ ├── TextFormatter.hpp │ │ │ │ ├── Utf16.hpp │ │ │ │ └── Utf8.hpp │ │ │ ├── Memory │ │ │ │ ├── Alignment.hpp │ │ │ │ ├── MemoryPool.hpp │ │ │ │ └── StringSlot.hpp │ │ │ ├── Misc │ │ │ │ ├── SerializedValue.hpp │ │ │ │ └── Visitable.hpp │ │ │ ├── MsgPack │ │ │ │ ├── MsgPackDeserializer.hpp │ │ │ │ ├── MsgPackSerializer.hpp │ │ │ │ ├── endianess.hpp │ │ │ │ └── ieee754.hpp │ │ │ ├── Namespace.hpp │ │ │ ├── Numbers │ │ │ │ ├── Float.hpp │ │ │ │ ├── FloatParts.hpp │ │ │ │ ├── FloatTraits.hpp │ │ │ │ ├── Integer.hpp │ │ │ │ ├── arithmeticCompare.hpp │ │ │ │ ├── convertNumber.hpp │ │ │ │ ├── parseFloat.hpp │ │ │ │ ├── parseInteger.hpp │ │ │ │ └── parseNumber.hpp │ │ │ ├── Object │ │ │ │ ├── MemberProxy.hpp │ │ │ │ ├── ObjectFunctions.hpp │ │ │ │ ├── ObjectImpl.hpp │ │ │ │ ├── ObjectIterator.hpp │ │ │ │ ├── ObjectRef.hpp │ │ │ │ ├── ObjectShortcuts.hpp │ │ │ │ └── Pair.hpp │ │ │ ├── Polyfills │ │ │ │ ├── alias_cast.hpp │ │ │ │ ├── assert.hpp │ │ │ │ ├── attributes.hpp │ │ │ │ ├── ctype.hpp │ │ │ │ ├── gsl │ │ │ │ │ └── not_null.hpp │ │ │ │ ├── limits.hpp │ │ │ │ ├── math.hpp │ │ │ │ ├── mpl │ │ │ │ │ └── max.hpp │ │ │ │ ├── pgmspace.hpp │ │ │ │ ├── safe_strcmp.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ ├── type_traits │ │ │ │ │ ├── conditional.hpp │ │ │ │ │ ├── declval.hpp │ │ │ │ │ ├── enable_if.hpp │ │ │ │ │ ├── integral_constant.hpp │ │ │ │ │ ├── is_array.hpp │ │ │ │ │ ├── is_base_of.hpp │ │ │ │ │ ├── is_class.hpp │ │ │ │ │ ├── is_const.hpp │ │ │ │ │ ├── is_convertible.hpp │ │ │ │ │ ├── is_enum.hpp │ │ │ │ │ ├── is_floating_point.hpp │ │ │ │ │ ├── is_integral.hpp │ │ │ │ │ ├── is_same.hpp │ │ │ │ │ ├── is_signed.hpp │ │ │ │ │ ├── is_unsigned.hpp │ │ │ │ │ ├── make_unsigned.hpp │ │ │ │ │ ├── remove_const.hpp │ │ │ │ │ ├── remove_reference.hpp │ │ │ │ │ └── type_identity.hpp │ │ │ │ └── utility.hpp │ │ │ ├── Serialization │ │ │ │ ├── Writer.hpp │ │ │ │ ├── Writers │ │ │ │ │ ├── ArduinoStringWriter.hpp │ │ │ │ │ ├── DummyWriter.hpp │ │ │ │ │ ├── PrintWriter.hpp │ │ │ │ │ ├── StaticStringWriter.hpp │ │ │ │ │ ├── StdStreamWriter.hpp │ │ │ │ │ └── StdStringWriter.hpp │ │ │ │ ├── measure.hpp │ │ │ │ └── serialize.hpp │ │ │ ├── StringStorage │ │ │ │ ├── StringCopier.hpp │ │ │ │ ├── StringMover.hpp │ │ │ │ └── StringStorage.hpp │ │ │ ├── Strings │ │ │ │ ├── ArduinoStringAdapter.hpp │ │ │ │ ├── ConstRamStringAdapter.hpp │ │ │ │ ├── FlashStringAdapter.hpp │ │ │ │ ├── FlashStringIterator.hpp │ │ │ │ ├── IsString.hpp │ │ │ │ ├── IsWriteableString.hpp │ │ │ │ ├── RamStringAdapter.hpp │ │ │ │ ├── SizedFlashStringAdapter.hpp │ │ │ │ ├── SizedRamStringAdapter.hpp │ │ │ │ ├── StlStringAdapter.hpp │ │ │ │ ├── StoragePolicy.hpp │ │ │ │ ├── String.hpp │ │ │ │ └── StringAdapters.hpp │ │ │ ├── Variant │ │ │ │ ├── SlotFunctions.hpp │ │ │ │ ├── VariantAs.hpp │ │ │ │ ├── VariantAsImpl.hpp │ │ │ │ ├── VariantCompare.hpp │ │ │ │ ├── VariantContent.hpp │ │ │ │ ├── VariantData.hpp │ │ │ │ ├── VariantFunctions.hpp │ │ │ │ ├── VariantImpl.hpp │ │ │ │ ├── VariantOperators.hpp │ │ │ │ ├── VariantRef.hpp │ │ │ │ ├── VariantShortcuts.hpp │ │ │ │ ├── VariantSlot.hpp │ │ │ │ └── VariantTo.hpp │ │ │ ├── compatibility.hpp │ │ │ └── version.hpp │ │ │ └── CMakeLists.txt │ ├── DHT_sensor_library │ │ ├── .DS_Store │ │ ├── CONTRIBUTING.md │ │ ├── DHT.cpp │ │ ├── DHT.h │ │ ├── DHT_U.cpp │ │ ├── DHT_U.h │ │ ├── README.md │ │ ├── code-of-conduct.md │ │ ├── examples │ │ │ ├── .DS_Store │ │ │ ├── DHT_Unified_Sensor │ │ │ │ └── DHT_Unified_Sensor.ino │ │ │ └── DHTtester │ │ │ │ └── DHTtester.ino │ │ ├── keywords.txt │ │ ├── library.properties │ │ └── license.txt │ ├── QRCode-Library │ │ ├── .gitignore │ │ ├── LICENSE.txt │ │ ├── README.md │ │ ├── examples │ │ │ └── QRCode │ │ │ │ └── QRCode.ino │ │ ├── generate_table.py │ │ ├── keywords.txt │ │ ├── library.properties │ │ ├── src │ │ │ ├── qrcode.c │ │ │ └── qrcode.h │ │ └── tests │ │ │ ├── BitBuffer.cpp │ │ │ ├── BitBuffer.hpp │ │ │ ├── QrCode.cpp │ │ │ ├── QrCode.hpp │ │ │ ├── QrSegment.cpp │ │ │ ├── QrSegment.hpp │ │ │ ├── README.md │ │ │ ├── run-tests.cpp │ │ │ └── run.sh │ ├── Time-Library │ │ ├── DateStrings.cpp │ │ ├── Readme.md │ │ ├── Time.cpp │ │ ├── Time.h │ │ ├── TimeLib.h │ │ ├── docs │ │ │ └── issue_template.md │ │ ├── examples │ │ │ ├── Processing │ │ │ │ └── SyncArduinoClock │ │ │ │ │ ├── SyncArduinoClock.pde │ │ │ │ │ └── readme.txt │ │ │ ├── TimeArduinoDue │ │ │ │ └── TimeArduinoDue.ino │ │ │ ├── TimeGPS │ │ │ │ └── TimeGPS.ino │ │ │ ├── TimeNTP │ │ │ │ └── TimeNTP.ino │ │ │ ├── TimeNTP_ENC28J60 │ │ │ │ └── TimeNTP_ENC28J60.ino │ │ │ ├── TimeNTP_ESP8266WiFi │ │ │ │ └── TimeNTP_ESP8266WiFi.ino │ │ │ ├── TimeRTC │ │ │ │ └── TimeRTC.ino │ │ │ ├── TimeRTCLog │ │ │ │ └── TimeRTCLog.ino │ │ │ ├── TimeRTCSet │ │ │ │ └── TimeRTCSet.ino │ │ │ ├── TimeSerial │ │ │ │ └── TimeSerial.ino │ │ │ ├── TimeSerialDateStrings │ │ │ │ └── TimeSerialDateStrings.ino │ │ │ └── TimeTeensy3 │ │ │ │ └── TimeTeensy3.ino │ │ ├── keywords.txt │ │ ├── library.json │ │ └── library.properties │ └── U8g2 │ │ ├── LICENSE │ │ ├── README.md │ │ ├── examples │ │ ├── full_buffer │ │ │ ├── FPS │ │ │ │ └── FPS.ino │ │ │ ├── FontUsage │ │ │ │ └── FontUsage.ino │ │ │ ├── GraphicsTest │ │ │ │ └── GraphicsTest.ino │ │ │ ├── HelloWorld │ │ │ │ └── HelloWorld.ino │ │ │ ├── IconMenu │ │ │ │ └── IconMenu.ino │ │ │ ├── PrintUTF8 │ │ │ │ └── PrintUTF8.ino │ │ │ ├── ScreenShot │ │ │ │ └── ScreenShot.ino │ │ │ ├── SelectionList │ │ │ │ └── SelectionList.ino │ │ │ ├── Shennong │ │ │ │ └── Shennong.ino │ │ │ ├── U8g2Logo │ │ │ │ └── U8g2Logo.ino │ │ │ ├── UpdateArea │ │ │ │ └── UpdateArea.ino │ │ │ └── Weather │ │ │ │ └── Weather.ino │ │ ├── games │ │ │ ├── LittleRookChess │ │ │ │ └── LittleRookChess.ino │ │ │ └── SpaceTrash │ │ │ │ └── SpaceTrash.ino │ │ ├── page_buffer │ │ │ ├── A2Printer │ │ │ │ └── A2Printer.ino │ │ │ ├── Chinese │ │ │ │ └── Chinese.ino │ │ │ ├── ClipWindow │ │ │ │ └── ClipWindow.ino │ │ │ ├── Clock │ │ │ │ └── Clock.ino │ │ │ ├── ContrastTest │ │ │ │ └── ContrastTest.ino │ │ │ ├── Devanagari │ │ │ │ └── Devanagari.ino │ │ │ ├── DirectAccess │ │ │ │ └── DirectAccess.ino │ │ │ ├── DrawLog │ │ │ │ └── DrawLog.ino │ │ │ ├── ExtUTF8 │ │ │ │ └── ExtUTF8.ino │ │ │ ├── FPS │ │ │ │ └── FPS.ino │ │ │ ├── FlipMode │ │ │ │ └── FlipMode.ino │ │ │ ├── GraphicsTest │ │ │ │ └── GraphicsTest.ino │ │ │ ├── HelloWorld │ │ │ │ └── HelloWorld.ino │ │ │ ├── IconMenu │ │ │ │ └── IconMenu.ino │ │ │ ├── Japanese │ │ │ │ └── Japanese.ino │ │ │ ├── Korean │ │ │ │ └── Korean.ino │ │ │ ├── LoadFromSD │ │ │ │ └── LoadFromSD.ino │ │ │ ├── PowerSaveTest │ │ │ │ └── PowerSaveTest.ino │ │ │ ├── PrintHelloWorld │ │ │ │ └── PrintHelloWorld.ino │ │ │ ├── PrintProgmem │ │ │ │ └── PrintProgmem.ino │ │ │ ├── PrintUTF8 │ │ │ │ └── PrintUTF8.ino │ │ │ ├── ScrollingText │ │ │ │ └── ScrollingText.ino │ │ │ ├── SelectionList │ │ │ │ └── SelectionList.ino │ │ │ ├── Serial │ │ │ │ └── Serial.ino │ │ │ ├── Shennong │ │ │ │ └── Shennong.ino │ │ │ ├── StateBufferLoop │ │ │ │ └── StateBufferLoop.ino │ │ │ ├── Terminal │ │ │ │ └── Terminal.ino │ │ │ ├── U8g2Logo │ │ │ │ └── U8g2Logo.ino │ │ │ ├── UpdatePartly │ │ │ │ └── UpdatePartly.ino │ │ │ ├── Weather │ │ │ │ └── Weather.ino │ │ │ ├── XBM │ │ │ │ └── XBM.ino │ │ │ └── XORTest │ │ │ │ └── XORTest.ino │ │ └── u8x8 │ │ │ ├── 16x16Font │ │ │ └── 16x16Font.ino │ │ │ ├── ArduboyTest │ │ │ └── ArduboyTest.ino │ │ │ ├── FlipMode │ │ │ └── FlipMode.ino │ │ │ ├── GraphicsTest │ │ │ └── GraphicsTest.ino │ │ │ ├── HelloWorld │ │ │ └── HelloWorld.ino │ │ │ ├── MessageBox │ │ │ └── MessageBox.ino │ │ │ └── Terminal │ │ │ └── Terminal.ino │ │ ├── extras │ │ └── ChangeLog │ │ ├── keywords.txt │ │ ├── library.properties │ │ └── src │ │ ├── U8g2lib.cpp │ │ ├── U8g2lib.h │ │ ├── U8x8lib.cpp │ │ ├── U8x8lib.h │ │ └── clib │ │ ├── u8g2.h │ │ ├── u8g2_bitmap.c │ │ ├── u8g2_box.c │ │ ├── u8g2_buffer.c │ │ ├── u8g2_circle.c │ │ ├── u8g2_cleardisplay.c │ │ ├── u8g2_d_memory.c │ │ ├── u8g2_d_setup.c │ │ ├── u8g2_font.c │ │ ├── u8g2_fonts.c │ │ ├── u8g2_hvline.c │ │ ├── u8g2_input_value.c │ │ ├── u8g2_intersection.c │ │ ├── u8g2_kerning.c │ │ ├── u8g2_line.c │ │ ├── u8g2_ll_hvline.c │ │ ├── u8g2_message.c │ │ ├── u8g2_polygon.c │ │ ├── u8g2_selection_list.c │ │ ├── u8g2_setup.c │ │ ├── u8log.c │ │ ├── u8log_u8g2.c │ │ ├── u8log_u8x8.c │ │ ├── u8x8.h │ │ ├── u8x8_8x8.c │ │ ├── u8x8_byte.c │ │ ├── u8x8_cad.c │ │ ├── u8x8_capture.c │ │ ├── u8x8_d_a2printer.c │ │ ├── u8x8_d_il3820_296x128.c │ │ ├── u8x8_d_ist3020.c │ │ ├── u8x8_d_ist7920.c │ │ ├── u8x8_d_ks0108.c │ │ ├── u8x8_d_lc7981.c │ │ ├── u8x8_d_ld7032_60x32.c │ │ ├── u8x8_d_ls013b7dh03.c │ │ ├── u8x8_d_max7219.c │ │ ├── u8x8_d_pcd8544_84x48.c │ │ ├── u8x8_d_pcf8812.c │ │ ├── u8x8_d_pcf8814_hx1230.c │ │ ├── u8x8_d_sbn1661.c │ │ ├── u8x8_d_sed1330.c │ │ ├── u8x8_d_sh1106_64x32.c │ │ ├── u8x8_d_sh1106_72x40.c │ │ ├── u8x8_d_sh1107.c │ │ ├── u8x8_d_sh1108.c │ │ ├── u8x8_d_sh1122.c │ │ ├── u8x8_d_ssd1305.c │ │ ├── u8x8_d_ssd1306_128x32.c │ │ ├── u8x8_d_ssd1306_128x64_noname.c │ │ ├── u8x8_d_ssd1306_48x64.c │ │ ├── u8x8_d_ssd1306_64x32.c │ │ ├── u8x8_d_ssd1306_64x48.c │ │ ├── u8x8_d_ssd1306_72x40.c │ │ ├── u8x8_d_ssd1306_96x16.c │ │ ├── u8x8_d_ssd1309.c │ │ ├── u8x8_d_ssd1316.c │ │ ├── u8x8_d_ssd1317.c │ │ ├── u8x8_d_ssd1318.c │ │ ├── u8x8_d_ssd1322.c │ │ ├── u8x8_d_ssd1325.c │ │ ├── u8x8_d_ssd1326.c │ │ ├── u8x8_d_ssd1327.c │ │ ├── u8x8_d_ssd1329.c │ │ ├── u8x8_d_ssd1606_172x72.c │ │ ├── u8x8_d_ssd1607_200x200.c │ │ ├── u8x8_d_st7511.c │ │ ├── u8x8_d_st75256.c │ │ ├── u8x8_d_st7528.c │ │ ├── u8x8_d_st75320.c │ │ ├── u8x8_d_st7565.c │ │ ├── u8x8_d_st7567.c │ │ ├── u8x8_d_st7586s_erc240160.c │ │ ├── u8x8_d_st7586s_s028hn118a.c │ │ ├── u8x8_d_st7588.c │ │ ├── u8x8_d_st7920.c │ │ ├── u8x8_d_t6963.c │ │ ├── u8x8_d_uc1601.c │ │ ├── u8x8_d_uc1604.c │ │ ├── u8x8_d_uc1608.c │ │ ├── u8x8_d_uc1610.c │ │ ├── u8x8_d_uc1611.c │ │ ├── u8x8_d_uc1617.c │ │ ├── u8x8_d_uc1638.c │ │ ├── u8x8_d_uc1701_dogs102.c │ │ ├── u8x8_d_uc1701_mini12864.c │ │ ├── u8x8_debounce.c │ │ ├── u8x8_display.c │ │ ├── u8x8_fonts.c │ │ ├── u8x8_gpio.c │ │ ├── u8x8_input_value.c │ │ ├── u8x8_message.c │ │ ├── u8x8_selection_list.c │ │ ├── u8x8_setup.c │ │ ├── u8x8_string.c │ │ ├── u8x8_u16toa.c │ │ └── u8x8_u8toa.c └── wificar │ ├── wificar.ino │ ├── wificar.ino.generic.bin │ └── wificar.ino.nodemcu.bin └── main.cpp /arduino/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/.DS_Store -------------------------------------------------------------------------------- /arduino/BlinkerIR/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/BlinkerIR/.DS_Store -------------------------------------------------------------------------------- /arduino/BlinkerIR/README.md: -------------------------------------------------------------------------------- 1 | #微信：yyxbc2010 #抖音：yyxbc2010 #西瓜视频 yyxbc2010 2 | 阳阳学编程抖音号视频中的实验源代码 3 | 项目说明： 4 | arduino/BlinkerIR 5 | esp8266+红外模块，实现遥控器功能 6 | 功能描述： 7 | 1.模拟家用电器的遥控器功能。 8 | 2.接入blinker平台，通过手机可以远程控制。 9 | 3.接入小爱同学、小度和天猫精灵，可以动动嘴就能控制你的家用电器。 10 | 4.带红外学习功能，只要用遥控器的电器设备都可以接入。 11 | 12 | 硬件准备 13 | 硬件： 14 | 1.红外发射模块 *1 15 | 2.红外接收模块 *1 16 | 3.Nodemcu(826612f) *1 17 | 4.面包板*1 18 | 5.杜邦线*4根 19 | 20 | 21 | 接线： 22 | 红外发射模块 | NodeMcu 23 | ---- | ----- 24 | IN | D2 25 | +5V |+5v 26 | GND |G 27 | 红外接入模块| NodeMcu 28 | DAT |D5 29 | VCC |+5v 30 | GND |G 31 | 32 | 33 | 教程配套工具包 34 | 下载地址链接:https://pan.baidu.com/s/1Xx6twjTJQ1rLUXIfV6zMcw 提取码:45yi 35 | -------------------------------------------------------------------------------- /arduino/BlinkerIR/images/blinkerir1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/BlinkerIR/images/blinkerir1.png -------------------------------------------------------------------------------- /arduino/BlinkerIR/images/blinkerir2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/BlinkerIR/images/blinkerir2.png -------------------------------------------------------------------------------- /arduino/BlinkerIR/images/blinkerir3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/BlinkerIR/images/blinkerir3.png -------------------------------------------------------------------------------- /arduino/BlinkerIR/images/blinkerir4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/BlinkerIR/images/blinkerir4.png -------------------------------------------------------------------------------- /arduino/BlinkerIR/images/blinkerir5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/BlinkerIR/images/blinkerir5.png -------------------------------------------------------------------------------- /arduino/blinker_NodeMcu_mi_duer_aligenie_IR_control/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_NodeMcu_mi_duer_aligenie_IR_control/.DS_Store -------------------------------------------------------------------------------- /arduino/blinker_NodeMcu_mi_duer_aligenie_IR_control/blinker_NodeMcu_mi_duer_aligenie_IR_control.ino.nodemcu.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_NodeMcu_mi_duer_aligenie_IR_control/blinker_NodeMcu_mi_duer_aligenie_IR_control.ino.nodemcu.bin -------------------------------------------------------------------------------- /arduino/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch/.DS_Store -------------------------------------------------------------------------------- /arduino/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino.generic_0.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino.generic_0.bin -------------------------------------------------------------------------------- /arduino/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino.generic_1.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch/blinker_esp8266-01s_mi_duer_aligenie_physicsSwitch.ino.generic_1.bin -------------------------------------------------------------------------------- /arduino/blinker_led_Aligenie_shuangkai/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_led_Aligenie_shuangkai/.DS_Store -------------------------------------------------------------------------------- /arduino/blinker_led_Aligenie_shuangkai/blinker_led_Aligenie_shuangkai.ino.nodemcu.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_led_Aligenie_shuangkai/blinker_led_Aligenie_shuangkai.ino.nodemcu.bin -------------------------------------------------------------------------------- /arduino/blinker_mi_dur_ali_button_4_dht_warn_wificfg/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_mi_dur_ali_button_4_dht_warn_wificfg/.DS_Store -------------------------------------------------------------------------------- /arduino/blinker_mi_dur_ali_button_4_dht_warn_wificfg/blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino.nodemcu_点动模式.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_mi_dur_ali_button_4_dht_warn_wificfg/blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino.nodemcu_点动模式.bin -------------------------------------------------------------------------------- /arduino/blinker_mi_dur_ali_button_4_dht_warn_wificfg/blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino.nodemcu_自锁模式.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/blinker_mi_dur_ali_button_4_dht_warn_wificfg/blinker_mi_dur_ali_button_4_dht_warn_wificfg.ino.nodemcu_自锁模式.bin -------------------------------------------------------------------------------- /arduino/esp8266FansClock/README.md: -------------------------------------------------------------------------------- 1 | #微信：yyxbc2010 2 | 阳阳学编程抖音号视频中的实验源代码 3 | 项目说明： 4 | 1，arduino/esp8266FansClock 5 | 抖音粉丝灯牌，esp8266开发板接入oled显示屏和获取抖音粉丝个数，获赞数用显示屏显示。 6 | -------------------------------------------------------------------------------- /arduino/esp8266http-example/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/esp8266http-example/.DS_Store -------------------------------------------------------------------------------- /arduino/images/blinkerir1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/images/blinkerir1.png -------------------------------------------------------------------------------- /arduino/images/blinkerir2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/images/blinkerir2.png -------------------------------------------------------------------------------- /arduino/images/blinkerir3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/images/blinkerir3.png -------------------------------------------------------------------------------- /arduino/images/blinkerir4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/images/blinkerir4.png -------------------------------------------------------------------------------- /arduino/images/blinkerir5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/images/blinkerir5.png -------------------------------------------------------------------------------- /arduino/libraries/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/.DS_Store -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_ESP8266/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/Adafruit_ESP8266/.DS_Store -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_ESP8266/README.md: -------------------------------------------------------------------------------- 1 | # Adafruit_ESP8266 [![Build Status](https://github.com/adafruit/Adafruit_ESP8266/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_ESP8266/actions) 2 | 3 | Example code for ESP8266 chipset 4 | -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_ESP8266/examples/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/Adafruit_ESP8266/examples/.DS_Store -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_ESP8266/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit ESP8266 2 | version=1.1.0 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=Example code for ESP8266 chipset 6 | paragraph=Example code for ESP8266 chipset 7 | category=Communication 8 | url=https://github.com/adafruit/Adafruit_ESP8266 9 | architectures=* 10 | -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_SSD1306/library.properties: -------------------------------------------------------------------------------- 1 | name=Adafruit SSD1306 2 | version=2.4.0 3 | author=Adafruit 4 | maintainer=Adafruit 5 | sentence=SSD1306 oled driver library for monochrome 128x64 and 128x32 displays 6 | paragraph=SSD1306 oled driver library for monochrome 128x64 and 128x32 displays 7 | category=Display 8 | url=https://github.com/adafruit/Adafruit_SSD1306 9 | architectures=* 10 | depends=Adafruit GFX Library 11 | -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_SSD1306/scripts/Makefile: -------------------------------------------------------------------------------- 1 | 2 | PY=python3 3 | 4 | splash.h: make_splash.py splash1.png splash2.png 5 | ${PY} make_splash.py splash1.png splash1 >$@ 6 | ${PY} make_splash.py splash2.png splash2 >>$@ 7 | 8 | clean: 9 | rm -f splash.h 10 | 11 | -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_SSD1306/scripts/make_splash.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # pip install pillow to get the PIL module 3 | 4 | import sys 5 | from PIL import Image 6 | 7 | def main(fn, id): 8 | image = Image.open(fn) 9 | print("\n" 10 | "#define {id}_width {w}\n" 11 | "#define {id}_height {h}\n" 12 | "\n" 13 | "const uint8_t PROGMEM {id}_data[] = {{\n" 14 | .format(id=id, w=image.width, h=image.height), end='') 15 | for y in range(0, image.height): 16 | for x in range(0, (image.width + 7)//8 * 8): 17 | if x == 0: 18 | print(" ", end='') 19 | if x % 8 == 0: 20 | print("B", end='') 21 | 22 | bit = '0' 23 | if x < image.width and image.getpixel((x,y)) != 0: 24 | bit = '1' 25 | print(bit, end='') 26 | 27 | if x % 8 == 7: 28 | print(",", end='') 29 | print() 30 | print("};") 31 | 32 | if __name__ == '__main__': 33 | if len(sys.argv) < 3: 34 | print("Usage: {} \n".format(sys.argv[0]), file=sys.stderr); 35 | sys.exit(1) 36 | fn = sys.argv[1] 37 | id = sys.argv[2] 38 | main(fn, id) 39 | -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_SSD1306/scripts/splash1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/Adafruit_SSD1306/scripts/splash1.png -------------------------------------------------------------------------------- /arduino/libraries/Adafruit_SSD1306/scripts/splash2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/Adafruit_SSD1306/scripts/splash2.png -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/ArduinoJson.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include "src/ArduinoJson.h" 6 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | cmake_minimum_required(VERSION 3.0) 6 | 7 | project(ArduinoJson VERSION 6.16.1) 8 | 9 | if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) 10 | include(CTest) 11 | endif() 12 | 13 | add_subdirectory(src) 14 | 15 | if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING) 16 | include(extras/CompileOptions.cmake) 17 | add_subdirectory(extras/tests) 18 | add_subdirectory(extras/fuzzing) 19 | endif() 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contribution to ArduinoJson 2 | 3 | First, thank you for taking the time to contribute to this project. 4 | 5 | You can submit changes via GitHub Pull Requests. 6 | 7 | Please: 8 | 9 | 1. Unit test every change in behavior 10 | 2. Use clang-format in "file" mode to format the code 11 | 3. Consider using the Continuous Integration (Travis and AppVeyor) 12 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | --------------------- 3 | 4 | Copyright © 2014-2020 Benoit BLANCHON 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: 7 | 8 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. 9 | 10 | THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 11 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/SUPPORT.md: -------------------------------------------------------------------------------- 1 | # ArduinoJson Support 2 | 3 | First off, thank you very much for using ArduinoJson. 4 | 5 | We'll be very happy to help you, but first please read the following. 6 | 7 | ## Before asking for help 8 | 9 | 1. Read the [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=support) 10 | 2. Search in the [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=support) 11 | 12 | If you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new). 13 | 14 | It is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue. 15 | 16 | ## Before hitting the Submit button 17 | 18 | Please provide all the relevant information: 19 | 20 | * Good title 21 | * Short description of the problem 22 | * Target platform 23 | * Compiler model and version 24 | * [MVCE](https://stackoverflow.com/help/mcve) 25 | * Compiler output 26 | 27 | Good questions get fast answers! 28 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/appveyor.yml: -------------------------------------------------------------------------------- 1 | version: 6.16.1.{build} 2 | environment: 3 | matrix: 4 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 5 | CMAKE_GENERATOR: Visual Studio 16 2019 6 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 7 | CMAKE_GENERATOR: Visual Studio 15 2017 8 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015 9 | CMAKE_GENERATOR: Visual Studio 14 2015 10 | - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013 11 | CMAKE_GENERATOR: Visual Studio 12 2013 12 | - CMAKE_GENERATOR: Visual Studio 11 2012 13 | - CMAKE_GENERATOR: Visual Studio 10 2010 14 | - CMAKE_GENERATOR: MinGW Makefiles 15 | configuration: Debug 16 | before_build: 17 | - set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW 18 | - cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" . 19 | build_script: 20 | - cmake --build . --config %CONFIGURATION% 21 | test_script: 22 | - ctest -C %CONFIGURATION% --output-on-failure . 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/component.mk: -------------------------------------------------------------------------------- 1 | COMPONENT_ADD_INCLUDEDIRS := src 2 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ArduinoJsonConfig.cmake.in: -------------------------------------------------------------------------------- 1 | @PACKAGE_INIT@ 2 | 3 | include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake") 4 | check_required_components("@PROJECT_NAME@") 5 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ci/arduino.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -eux 2 | 3 | /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_1.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :1 -ac -screen 0 1280x1024x16 4 | sleep 3 5 | export DISPLAY=:1.0 6 | 7 | mkdir -p /tmp/arduino 8 | curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tar.xz | tar xJ -C /tmp/arduino --strip 1 || 9 | curl -sS http://downloads.arduino.cc/arduino-$VERSION-linux64.tgz | tar xz -C /tmp/arduino --strip 1 10 | export PATH=$PATH:/tmp/arduino/ 11 | 12 | if [[ "$BOARD" =~ "arduino:samd:" ]]; then 13 | arduino --install-boards arduino:samd 14 | fi 15 | 16 | ln -s $PWD /tmp/arduino/libraries/ArduinoJson 17 | 18 | for EXAMPLE in $PWD/examples/*/*.ino; do 19 | arduino --verify --board $BOARD $EXAMPLE 20 | done 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ci/build.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh -ex 2 | 3 | export CC="$_CC" 4 | export CXX="$_CXX" 5 | 6 | cmake -DCMAKE_BUILD_TYPE=Release . 7 | cmake --build . 8 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ci/coverage.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh -eux 2 | 3 | cmake -DCOVERAGE=true . 4 | make 5 | make test 6 | 7 | pip install --user cpp-coveralls 'requests[security]' 8 | pwd 9 | coveralls --include 'src' --gcov-options '\-lp' 10 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ci/fuzz.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -eux 2 | 3 | ROOT_DIR=$(dirname $0)/../../ 4 | FUZZING_DIR=${ROOT_DIR}/extras/fuzzing/ 5 | 6 | export CC="clang-${CLANG}" 7 | export CXX="clang++-${CLANG}" 8 | cmake -DCMAKE_BUILD_TYPE=Debug . 9 | 10 | FUZZER_TARGET="${FUZZER}_fuzzer" 11 | FUZZER_PATH="extras/fuzzing/${FUZZER_TARGET}" 12 | CORPUS_DIR="${FUZZING_DIR}/${FUZZER}_corpus" 13 | SEED_CORPUS_DIR="${FUZZING_DIR}/${FUZZER}_seed_corpus" 14 | 15 | cmake --build . --target $FUZZER_TARGET 16 | 17 | export ASAN_OPTIONS="detect_leaks=0" 18 | export LLVM_PROFILE_FILE="${FUZZER_TARGET}.profraw" 19 | ${FUZZER_PATH} "$CORPUS_DIR" "$SEED_CORPUS_DIR" -max_total_time=60 -timeout=1 20 | 21 | llvm-profdata-${CLANG} merge -sparse ${LLVM_PROFILE_FILE} -o ${FUZZER_TARGET}.profdata 22 | llvm-cov-${CLANG} report ./${FUZZER_PATH} -instr-profile=${FUZZER_TARGET}.profdata 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ci/platformio.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh -eux 2 | 3 | pip install --user platformio 4 | 5 | case $BOARD in 6 | uno) 7 | platformio lib install 868 # SD library 8 | platformio lib install 872 # Ethernet library 9 | ;; 10 | esp01) 11 | platformio lib uninstall 161 || true 12 | platformio lib uninstall 868 || true 13 | platformio lib uninstall 872 || true 14 | ;; 15 | esac 16 | 17 | for EXAMPLE in $PWD/examples/*/*.ino; 18 | do 19 | platformio ci $EXAMPLE -l '.' -b $BOARD 20 | done 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/ci/test.sh: -------------------------------------------------------------------------------- 1 | #!/bin/sh -ex 2 | 3 | export CC="$_CC" 4 | export CXX="$_CXX" 5 | 6 | [ -n "$SANITIZE" ] && export CXXFLAGS="-fsanitize=$SANITIZE" 7 | 8 | cmake -DCMAKE_BUILD_TYPE=Debug . 9 | cmake --build . 10 | ctest --output-on-failure . 11 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/Makefile: -------------------------------------------------------------------------------- 1 | # CAUTION: this file is invoked by https://github.com/google/oss-fuzz 2 | 3 | CXXFLAGS += -I../../src -DARDUINOJSON_DEBUG=1 4 | 5 | all: \ 6 | $(OUT)/json_fuzzer \ 7 | $(OUT)/json_fuzzer_seed_corpus.zip \ 8 | $(OUT)/json_fuzzer.options \ 9 | $(OUT)/msgpack_fuzzer \ 10 | $(OUT)/msgpack_fuzzer_seed_corpus.zip \ 11 | $(OUT)/msgpack_fuzzer.options 12 | 13 | $(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../../src -type f) 14 | $(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE) 15 | 16 | $(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/* 17 | zip -j $@ $? 18 | 19 | $(OUT)/%_fuzzer.options: 20 | @echo "[libfuzzer]" > $@ 21 | @echo "max_len = 256" >> $@ 22 | @echo "timeout = 10" >> $@ 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_fuzzer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 4 | DynamicJsonDocument doc(4096); 5 | DeserializationError error = deserializeJson(doc, data, size); 6 | if (!error) { 7 | std::string json; 8 | serializeJson(doc, json); 9 | } 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/Comments.json: -------------------------------------------------------------------------------- 1 | //comment 2 | /*comment*/ 3 | [ //comment 4 | /*comment*/"comment"/*comment*/,//comment 5 | /*comment*/{//comment 6 | /* comment*/"key"//comment 7 | : //comment 8 | "value"//comment 9 | }/*comment*/ 10 | ]//comment -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/EmptyArray.json: -------------------------------------------------------------------------------- 1 | [] -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/EmptyObject.json: -------------------------------------------------------------------------------- 1 | {} -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/ExcessiveNesting.json: -------------------------------------------------------------------------------- 1 | [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20,[21,[22,[23,[24,[25,[26,[27,[28,[29,[30,[31,[32,[33,[34,[35,[36,[37,[38,[39,[40,[41,[42,[43,[44,[45,[46,[47,[48,[49,[50,[51,[52,[53,[54,[55,[56,[57,[58,[59,[60,[61,[62,[63,[64,[65,[66,[67,[68,[69,[70,[71,[72,[73,[74,[75,[76,[77,[78,[79,[80,[81,[82,[83,[84,[85,[86,[87,[88,[89,[90,[91,[92,[93,[94,[95,[96,[97,[98,[99,[100,[101,[102,[103,[104,[105,[106,[107,[108,[109,[110,[111,[112,[113,[114,[115,[116,[117,[118,[119,[120]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]] -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/IntegerOverflow.json: -------------------------------------------------------------------------------- 1 | 9720730739393920739 2 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/Numbers.json: -------------------------------------------------------------------------------- 1 | [ 2 | 123, 3 | -123, 4 | 123.456, 5 | -123.456, 6 | 12e34, 7 | 12e-34, 8 | 12e+34, 9 | 12E34, 10 | 12E-34, 11 | 12E+34, 12 | 12.34e56, 13 | 12.34e-56, 14 | 12.34e+56, 15 | 12.34E56, 16 | 12.34E-56, 17 | 12.34E+56, 18 | NaN, 19 | -NaN, 20 | +NaN, 21 | Infinity, 22 | +Infinity, 23 | -Infinity 24 | ] -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/OpenWeatherMap.json: -------------------------------------------------------------------------------- 1 | { 2 | "coord": { 3 | "lon": -0.13, 4 | "lat": 51.51 5 | }, 6 | "weather": [ 7 | { 8 | "id": 301, 9 | "main": "Drizzle", 10 | "description": "drizzle", 11 | "icon": "09n" 12 | }, 13 | { 14 | "id": 701, 15 | "main": "Mist", 16 | "description": "mist", 17 | "icon": "50n" 18 | }, 19 | { 20 | "id": 741, 21 | "main": "Fog", 22 | "description": "fog", 23 | "icon": "50n" 24 | } 25 | ], 26 | "base": "stations", 27 | "main": { 28 | "temp": 281.87, 29 | "pressure": 1032, 30 | "humidity": 100, 31 | "temp_min": 281.15, 32 | "temp_max": 283.15 33 | }, 34 | "visibility": 2900, 35 | "wind": { 36 | "speed": 1.5 37 | }, 38 | "clouds": { 39 | "all": 90 40 | }, 41 | "dt": 1483820400, 42 | "sys": { 43 | "type": 1, 44 | "id": 5091, 45 | "message": 0.0226, 46 | "country": "GB", 47 | "sunrise": 1483776245, 48 | "sunset": 1483805443 49 | }, 50 | "id": 2643743, 51 | "name": "London", 52 | "cod": 200 53 | } 54 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/json_seed_corpus/Strings.json: -------------------------------------------------------------------------------- 1 | [ 2 | "hello", 3 | 'hello', 4 | hello, 5 | {"hello":"world"}, 6 | {'hello':'world'}, 7 | {hello:world} 8 | ] -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_fuzzer.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 4 | DynamicJsonDocument doc(4096); 5 | DeserializationError error = deserializeMsgPack(doc, data, size); 6 | if (!error) { 7 | std::string json; 8 | serializeMsgPack(doc, json); 9 | } 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/array16: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/array16 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/array32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/array32 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/false: -------------------------------------------------------------------------------- 1 | � -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixarray: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixarray -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixint_negative: -------------------------------------------------------------------------------- 1 | � -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixint_positive: -------------------------------------------------------------------------------- 1 |  -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixmap: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixmap -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixstr: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/fixstr -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/float32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/float32 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/float64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/float64 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int16: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int16 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int32 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int64 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int8: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/int8 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/map16: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/map16 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/map32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/map32 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/nil: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/nil -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/str16: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/str16 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/str32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/str32 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/str8: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/str8 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/true: -------------------------------------------------------------------------------- 1 | � -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint16: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint16 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint32: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint32 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint64 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint8: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/toddpan/yyxbc/ef1d21fa5c73e556fa01cd61f5cee2a329a18cfb/arduino/libraries/ArduinoJson/extras/fuzzing/msgpack_seed_corpus/uint8 -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/scripts/build-arduino-package.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | TAG=$(git describe) 4 | OUTPUT="ArduinoJson-$TAG.zip" 5 | 6 | cd $(dirname $0)/../../.. 7 | 8 | # remove existing file 9 | rm -f $OUTPUT 10 | 11 | # create zip 12 | 7z a $OUTPUT \ 13 | -xr!.vs \ 14 | ArduinoJson/CHANGELOG.md \ 15 | ArduinoJson/examples \ 16 | ArduinoJson/src \ 17 | ArduinoJson/keywords.txt \ 18 | ArduinoJson/library.properties \ 19 | ArduinoJson/LICENSE.md \ 20 | ArduinoJson/README.md \ 21 | ArduinoJson/ArduinoJson.h 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/scripts/publish-particle-library.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -eu 4 | 5 | SOURCE_DIR="$(dirname "$0")/../.." 6 | WORK_DIR=$(mktemp -d) 7 | trap 'rm -rf "$WORK_DIR"' EXIT 8 | 9 | cp "$SOURCE_DIR/README.md" "$WORK_DIR/README.md" 10 | cp "$SOURCE_DIR/CHANGELOG.md" "$WORK_DIR/CHANGELOG.md" 11 | cp "$SOURCE_DIR/library.properties" "$WORK_DIR/library.properties" 12 | cp "$SOURCE_DIR/LICENSE.md" "$WORK_DIR/LICENSE.txt" 13 | cp -r "$SOURCE_DIR/src" "$WORK_DIR/" 14 | cp -r "$SOURCE_DIR/examples" "$WORK_DIR/" 15 | 16 | cd "$WORK_DIR" 17 | particle library upload 18 | particle library publish 19 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/scripts/wandbox/publish.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -eu 4 | 5 | ARDUINOJSON_H="$1" 6 | 7 | read_string() { 8 | jq --slurp --raw-input '.' "$1" 9 | } 10 | 11 | compile() { 12 | FILE_PATH="$(dirname $0)/$1.cpp" 13 | cat >parameters.json < 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::add()") { 11 | DynamicJsonDocument doc(4096); 12 | doc.addElement(); 13 | ElementProxy ep = doc[0]; 14 | 15 | SECTION("add(int)") { 16 | ep.add(42); 17 | 18 | REQUIRE(doc.as() == "[[42]]"); 19 | } 20 | 21 | SECTION("add(const char*)") { 22 | ep.add("world"); 23 | 24 | REQUIRE(doc.as() == "[[\"world\"]]"); 25 | } 26 | 27 | SECTION("set(char[])") { 28 | char s[] = "world"; 29 | ep.add(s); 30 | strcpy(s, "!!!!!"); 31 | 32 | REQUIRE(doc.as() == "[[\"world\"]]"); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/ElementProxy/clear.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::clear()") { 11 | DynamicJsonDocument doc(4096); 12 | doc.addElement(); 13 | ElementProxy ep = doc[0]; 14 | 15 | SECTION("size goes back to zero") { 16 | ep.add(42); 17 | ep.clear(); 18 | 19 | REQUIRE(ep.size() == 0); 20 | } 21 | 22 | SECTION("isNull() return true") { 23 | ep.add("hello"); 24 | ep.clear(); 25 | 26 | REQUIRE(ep.isNull() == true); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/ElementProxy/compare.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::operator==()") { 11 | DynamicJsonDocument doc(4096); 12 | 13 | SECTION("1 vs 1") { 14 | doc.add(1); 15 | doc.add(1); 16 | 17 | REQUIRE(doc[0] <= doc[1]); 18 | REQUIRE(doc[0] == doc[1]); 19 | REQUIRE(doc[0] >= doc[1]); 20 | REQUIRE_FALSE(doc[0] != doc[1]); 21 | REQUIRE_FALSE(doc[0] < doc[1]); 22 | REQUIRE_FALSE(doc[0] > doc[1]); 23 | } 24 | 25 | SECTION("1 vs 2") { 26 | doc.add(1); 27 | doc.add(2); 28 | 29 | REQUIRE(doc[0] != doc[1]); 30 | REQUIRE(doc[0] < doc[1]); 31 | REQUIRE(doc[0] <= doc[1]); 32 | REQUIRE_FALSE(doc[0] == doc[1]); 33 | REQUIRE_FALSE(doc[0] > doc[1]); 34 | REQUIRE_FALSE(doc[0] >= doc[1]); 35 | } 36 | 37 | SECTION("'abc' vs 'bcd'") { 38 | doc.add("abc"); 39 | doc.add("bcd"); 40 | 41 | REQUIRE(doc[0] != doc[1]); 42 | REQUIRE(doc[0] < doc[1]); 43 | REQUIRE(doc[0] <= doc[1]); 44 | REQUIRE_FALSE(doc[0] == doc[1]); 45 | REQUIRE_FALSE(doc[0] > doc[1]); 46 | REQUIRE_FALSE(doc[0] >= doc[1]); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/ElementProxy/remove.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::remove()") { 11 | DynamicJsonDocument doc(4096); 12 | doc.addElement(); 13 | ElementProxy ep = doc[0]; 14 | 15 | SECTION("remove(int)") { 16 | ep.add(1); 17 | ep.add(2); 18 | ep.add(3); 19 | 20 | ep.remove(1); 21 | 22 | REQUIRE(ep.as() == "[1,3]"); 23 | } 24 | 25 | SECTION("remove(const char *)") { 26 | ep["a"] = 1; 27 | ep["b"] = 2; 28 | 29 | ep.remove("a"); 30 | 31 | REQUIRE(ep.as() == "{\"b\":2}"); 32 | } 33 | 34 | SECTION("remove(std::string)") { 35 | ep["a"] = 1; 36 | ep["b"] = 2; 37 | 38 | ep.remove(std::string("b")); 39 | 40 | REQUIRE(ep.as() == "{\"a\":1}"); 41 | } 42 | 43 | #ifdef HAS_VARIABLE_LENGTH_ARRAY 44 | SECTION("remove(vla)") { 45 | ep["a"] = 1; 46 | ep["b"] = 2; 47 | 48 | int i = 4; 49 | char vla[i]; 50 | strcpy(vla, "b"); 51 | ep.remove(vla); 52 | 53 | REQUIRE(ep.as() == "{\"a\":1}"); 54 | } 55 | #endif 56 | } 57 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/ElementProxy/set.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::set()") { 11 | DynamicJsonDocument doc(4096); 12 | ElementProxy ep = doc[0]; 13 | 14 | SECTION("set(int)") { 15 | ep.set(42); 16 | 17 | REQUIRE(doc.as() == "[42]"); 18 | } 19 | 20 | SECTION("set(const char*)") { 21 | ep.set("world"); 22 | 23 | REQUIRE(doc.as() == "[\"world\"]"); 24 | } 25 | 26 | SECTION("set(char[])") { 27 | char s[] = "world"; 28 | ep.set(s); 29 | strcpy(s, "!!!!!"); 30 | 31 | REQUIRE(doc.as() == "[\"world\"]"); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/ElementProxy/size.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::size()") { 11 | DynamicJsonDocument doc(4096); 12 | doc.addElement(); 13 | ElementProxy ep = doc[0]; 14 | 15 | SECTION("returns 0") { 16 | REQUIRE(ep.size() == 0); 17 | } 18 | 19 | SECTION("as an array, returns 2") { 20 | ep.add(1); 21 | ep.add(2); 22 | REQUIRE(ep.size() == 2); 23 | } 24 | 25 | SECTION("as an object, returns 2") { 26 | ep["a"] = 1; 27 | ep["b"] = 2; 28 | REQUIRE(ep.size() == 2); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/ElementProxy/subscript.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("ElementProxy::operator[]") { 11 | DynamicJsonDocument doc(4096); 12 | ElementProxy ep = doc[1]; 13 | 14 | SECTION("set member") { 15 | ep["world"] = 42; 16 | 17 | REQUIRE(doc.as() == "[null,{\"world\":42}]"); 18 | } 19 | 20 | SECTION("set element") { 21 | ep[2] = 42; 22 | 23 | REQUIRE(doc.as() == "[null,[null,null,42]]"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/FailingBuilds/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | macro(build_should_fail target) 6 | set_target_properties(${target} 7 | PROPERTIES 8 | EXCLUDE_FROM_ALL TRUE 9 | EXCLUDE_FROM_DEFAULT_BUILD TRUE 10 | ) 11 | add_test( 12 | NAME 13 | ${target} 14 | COMMAND 15 | ${CMAKE_COMMAND} --build . --target ${target} --config $ 16 | WORKING_DIRECTORY 17 | ${CMAKE_BINARY_DIR} 18 | ) 19 | set_tests_properties(${target} 20 | PROPERTIES 21 | WILL_FAIL TRUE 22 | ) 23 | endmacro() 24 | 25 | 26 | add_executable(Issue978 Issue978.cpp) 27 | build_should_fail(Issue978) 28 | 29 | add_executable(Issue1189 Issue1189.cpp) 30 | build_should_fail(Issue1189) 31 | 32 | add_executable(read_long_long read_long_long.cpp) 33 | set_property(TARGET read_long_long PROPERTY CXX_STANDARD 11) 34 | build_should_fail(read_long_long) 35 | 36 | add_executable(write_long_long write_long_long.cpp) 37 | set_property(TARGET write_long_long PROPERTY CXX_STANDARD 11) 38 | build_should_fail(write_long_long) 39 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/FailingBuilds/Issue1189.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | 7 | // a function should not be able to get a JsonDocument by value 8 | void f(JsonDocument) {} 9 | 10 | int main() { 11 | DynamicJsonDocument doc(1024); 12 | f(doc); 13 | } 14 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/FailingBuilds/Issue978.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | 7 | struct Stream {}; 8 | 9 | int main() { 10 | Stream* stream = 0; 11 | DynamicJsonDocument doc(1024); 12 | deserializeJson(doc, stream); 13 | } 14 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/FailingBuilds/read_long_long.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #define ARDUINOJSON_USE_LONG_LONG 0 6 | #include 7 | 8 | #if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8 9 | #error This test requires sizeof(long) < 8 10 | #endif 11 | 12 | #if !ARDUINOJSON_HAS_LONG_LONG 13 | #error This test requires C++11 14 | #endif 15 | 16 | ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(long long) 17 | int main() { 18 | DynamicJsonDocument doc(1024); 19 | doc["dummy"].as(); 20 | } 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/FailingBuilds/write_long_long.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #define ARDUINOJSON_USE_LONG_LONG 0 6 | #include 7 | 8 | #if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8 9 | #error This test requires sizeof(long) < 8 10 | #endif 11 | 12 | #if !ARDUINOJSON_HAS_LONG_LONG 13 | #error This test requires C++11 14 | #endif 15 | 16 | int main() { 17 | DynamicJsonDocument doc(1024); 18 | doc["dummy"] = static_cast(42); 19 | } 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Helpers/CustomReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | class CustomReader { 10 | std::stringstream _stream; 11 | 12 | public: 13 | CustomReader(const char* input) : _stream(input) {} 14 | 15 | int read() { 16 | return _stream.get(); 17 | } 18 | 19 | size_t readBytes(char* buffer, size_t length) { 20 | _stream.read(buffer, static_cast(length)); 21 | return static_cast(_stream.gcount()); 22 | } 23 | 24 | private: 25 | CustomReader(const CustomReader&); 26 | }; 27 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Helpers/Stream.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | // Reproduces Arduino's Stream class 8 | class Stream // : public Print 9 | { 10 | public: 11 | virtual ~Stream() {} 12 | virtual int read() = 0; 13 | virtual size_t readBytes(char *buffer, size_t length) = 0; 14 | }; 15 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Helpers/WString.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | // Reproduces Arduino's String class 10 | class String { 11 | public: 12 | String() {} 13 | explicit String(const char* s) : _str(s) {} 14 | 15 | String& operator+=(const char* rhs) { 16 | _str += rhs; 17 | return *this; 18 | } 19 | 20 | size_t length() const { 21 | return _str.size(); 22 | } 23 | 24 | const char* c_str() const { 25 | return _str.c_str(); 26 | } 27 | 28 | bool operator==(const char* s) const { 29 | return _str == s; 30 | } 31 | 32 | friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) { 33 | lhs << rhs._str; 34 | return lhs; 35 | } 36 | 37 | private: 38 | std::string _str; 39 | }; 40 | 41 | class StringSumHelper; 42 | 43 | inline bool operator==(const std::string& lhs, const ::String& rhs) { 44 | return lhs == rhs.c_str(); 45 | } 46 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Helpers/progmem_emulation.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include // uint8_t 6 | #include // strcmp, strlen... 7 | 8 | class __FlashStringHelper; 9 | 10 | inline const void* convertPtrToFlash(const void* s) { 11 | return reinterpret_cast(s) + 42; 12 | } 13 | 14 | inline const void* convertFlashToPtr(const void* s) { 15 | return reinterpret_cast(s) - 42; 16 | } 17 | 18 | #define F(X) reinterpret_cast(convertPtrToFlash(X)) 19 | #define FC(X) reinterpret_cast(convertPtrToFlash(X)) 20 | 21 | inline uint8_t pgm_read_byte(const void* p) { 22 | return *reinterpret_cast(convertFlashToPtr(p)); 23 | } 24 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/IntegrationTests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(IntegrationTests 6 | gbathree.cpp 7 | issue772.cpp 8 | round_trip.cpp 9 | openweathermap.cpp 10 | ) 11 | 12 | if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") 13 | target_compile_options(IntegrationTests 14 | PUBLIC 15 | -fsingle-precision-constant # issue 544 16 | ) 17 | endif() 18 | 19 | add_test(IntegrationTests IntegrationTests) 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/IntegrationTests/issue772.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | // https://github.com/bblanchon/ArduinoJson/issues/772 9 | 10 | TEST_CASE("Issue772") { 11 | DynamicJsonDocument doc1(4096); 12 | DynamicJsonDocument doc2(4096); 13 | DeserializationError err; 14 | std::string data = 15 | "{\"state\":{\"reported\":{\"timestamp\":\"2018-07-02T09:40:12Z\"," 16 | "\"mac\":\"2C3AE84FC076\",\"firmwareVersion\":\"v0.2.7-5-gf4d4d78\"," 17 | "\"visibleLight\":261,\"infraRed\":255,\"ultraViolet\":0.02," 18 | "\"Temperature\":26.63,\"Pressure\":101145.7,\"Humidity\":54.79883," 19 | "\"Vbat\":4.171261,\"soilMoisture\":0,\"ActB\":0}}}"; 20 | err = deserializeJson(doc1, data); 21 | REQUIRE(err == DeserializationError::Ok); 22 | 23 | data = ""; 24 | serializeMsgPack(doc1, data); 25 | err = deserializeMsgPack(doc2, data); 26 | 27 | REQUIRE(err == DeserializationError::Ok); 28 | } 29 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(JsonArrayTests 6 | add.cpp 7 | copyArray.cpp 8 | createNested.cpp 9 | equals.cpp 10 | get.cpp 11 | isNull.cpp 12 | iterator.cpp 13 | memoryUsage.cpp 14 | nesting.cpp 15 | remove.cpp 16 | size.cpp 17 | std_string.cpp 18 | subscript.cpp 19 | undefined.cpp 20 | ) 21 | 22 | add_test(JsonArray JsonArrayTests) 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/createNested.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonArray basics") { 9 | DynamicJsonDocument doc(4096); 10 | JsonArray array = doc.to(); 11 | 12 | SECTION("CreateNestedArray") { 13 | JsonArray arr = array.createNestedArray(); 14 | REQUIRE(arr == array[0].as()); 15 | } 16 | 17 | SECTION("CreateNestedObject") { 18 | JsonObject obj = array.createNestedObject(); 19 | REQUIRE(obj == array[0].as()); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/get.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonArray::get()") { 9 | DynamicJsonDocument doc(4096); 10 | deserializeJson(doc, "[1,2,3]"); 11 | JsonArray array = doc.as(); 12 | 13 | SECTION("Overflow") { 14 | REQUIRE(array.getElement(3).isNull()); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/iterator.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | template 9 | static void run_iterator_test() { 10 | StaticJsonDocument doc; 11 | JsonArray tmp = doc.to(); 12 | tmp.add(12); 13 | tmp.add(34); 14 | 15 | TArray array = tmp; 16 | typename TArray::iterator it = array.begin(); 17 | typename TArray::iterator end = array.end(); 18 | 19 | REQUIRE(end != it); 20 | REQUIRE(12 == it->template as()); 21 | REQUIRE(12 == static_cast(*it)); 22 | ++it; 23 | REQUIRE(end != it); 24 | REQUIRE(34 == it->template as()); 25 | REQUIRE(34 == static_cast(*it)); 26 | ++it; 27 | REQUIRE(end == it); 28 | } 29 | 30 | TEST_CASE("JsonArray::begin()/end()") { 31 | SECTION("Non null JsonArray") { 32 | run_iterator_test(); 33 | } 34 | 35 | SECTION("Null JsonArray") { 36 | JsonArray array; 37 | 38 | REQUIRE(array.begin() == array.end()); 39 | } 40 | } 41 | 42 | TEST_CASE("JsonArrayConst::begin()/end()") { 43 | SECTION("Non null JsonArrayConst") { 44 | run_iterator_test(); 45 | } 46 | 47 | SECTION("Null JsonArrayConst") { 48 | JsonArrayConst array; 49 | 50 | REQUIRE(array.begin() == array.end()); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/memoryUsage.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonArray::memoryUsage()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonArray arr = doc.to(); 11 | 12 | SECTION("return 0 if uninitialized") { 13 | JsonArray unitialized; 14 | REQUIRE(unitialized.memoryUsage() == 0); 15 | } 16 | 17 | SECTION("JSON_ARRAY_SIZE(0) if empty") { 18 | REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(0)); 19 | } 20 | 21 | SECTION("JSON_ARRAY_SIZE(1) after add") { 22 | arr.add("hello"); 23 | REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1)); 24 | } 25 | 26 | SECTION("includes the size of the string") { 27 | arr.add(std::string("hello")); 28 | REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1) + 6); 29 | } 30 | 31 | SECTION("includes the size of the nested array") { 32 | JsonArray nested = arr.createNestedArray(); 33 | nested.add(42); 34 | REQUIRE(arr.memoryUsage() == 2 * JSON_ARRAY_SIZE(1)); 35 | } 36 | 37 | SECTION("includes the size of the nested arrect") { 38 | JsonObject nested = arr.createNestedObject(); 39 | nested["hello"] = "world"; 40 | REQUIRE(arr.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1)); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/nesting.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonArray::nesting()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonArray arr = doc.to(); 11 | 12 | SECTION("return 0 if uninitialized") { 13 | JsonArray unitialized; 14 | REQUIRE(unitialized.nesting() == 0); 15 | } 16 | 17 | SECTION("returns 1 for empty array") { 18 | REQUIRE(arr.nesting() == 1); 19 | } 20 | 21 | SECTION("returns 1 for flat array") { 22 | arr.add("hello"); 23 | REQUIRE(arr.nesting() == 1); 24 | } 25 | 26 | SECTION("returns 2 with nested array") { 27 | arr.createNestedArray(); 28 | REQUIRE(arr.nesting() == 2); 29 | } 30 | 31 | SECTION("returns 2 with nested object") { 32 | arr.createNestedObject(); 33 | REQUIRE(arr.nesting() == 2); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/size.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonArray::size()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonArray array = doc.to(); 11 | 12 | SECTION("returns 0 is empty") { 13 | REQUIRE(0U == array.size()); 14 | } 15 | 16 | SECTION("increases after add()") { 17 | array.add("hello"); 18 | REQUIRE(1U == array.size()); 19 | 20 | array.add("world"); 21 | REQUIRE(2U == array.size()); 22 | } 23 | 24 | SECTION("remains the same after replacing an element") { 25 | array.add("hello"); 26 | REQUIRE(1U == array.size()); 27 | 28 | array[0] = "hello"; 29 | REQUIRE(1U == array.size()); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/std_string.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | static void eraseString(std::string &str) { 9 | char *p = const_cast(str.c_str()); 10 | while (*p) *p++ = '*'; 11 | } 12 | 13 | TEST_CASE("std::string") { 14 | DynamicJsonDocument doc(4096); 15 | JsonArray array = doc.to(); 16 | 17 | SECTION("add()") { 18 | std::string value("hello"); 19 | array.add(value); 20 | eraseString(value); 21 | REQUIRE(std::string("hello") == array[0]); 22 | } 23 | 24 | SECTION("operator[]") { 25 | std::string value("world"); 26 | array.add("hello"); 27 | array[0] = value; 28 | eraseString(value); 29 | REQUIRE(std::string("world") == array[0]); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonArray/undefined.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace Catch::Matchers; 9 | 10 | TEST_CASE("Undefined JsonArray") { 11 | JsonArray array; 12 | 13 | SECTION("SubscriptFails") { 14 | REQUIRE(array[0].isNull()); 15 | } 16 | 17 | SECTION("AddFails") { 18 | array.add(1); 19 | REQUIRE(0 == array.size()); 20 | } 21 | 22 | SECTION("CreateNestedArrayFails") { 23 | REQUIRE(array.createNestedArray().isNull()); 24 | } 25 | 26 | SECTION("CreateNestedObjectFails") { 27 | REQUIRE(array.createNestedObject().isNull()); 28 | } 29 | 30 | SECTION("PrintToWritesBrackets") { 31 | char buffer[32]; 32 | serializeJson(array, buffer, sizeof(buffer)); 33 | REQUIRE_THAT(buffer, Equals("null")); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDeserializer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(JsonDeserializerTests 6 | array.cpp 7 | array_static.cpp 8 | DeserializationError.cpp 9 | filter.cpp 10 | incomplete_input.cpp 11 | input_types.cpp 12 | invalid_input.cpp 13 | misc.cpp 14 | nestingLimit.cpp 15 | number.cpp 16 | object.cpp 17 | object_static.cpp 18 | string.cpp 19 | ) 20 | 21 | set_target_properties(JsonDeserializerTests PROPERTIES UNITY_BUILD OFF) 22 | 23 | add_test(JsonDeserializer JsonDeserializerTests) 24 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDeserializer/incomplete_input.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #define ARDUINOJSON_DECODE_UNICODE 1 6 | #include 7 | #include 8 | 9 | TEST_CASE("Truncated JSON input") { 10 | const char* testCases[] = {"\"hello", "\'hello", "'\\u", "'\\u00", "'\\u000", 11 | // false 12 | "f", "fa", "fal", "fals", 13 | // true 14 | "t", "tr", "tru", 15 | // null 16 | "n", "nu", "nul", 17 | // object 18 | "{", "{a", "{a:", "{a:1", "{a:1,", "{a:1,"}; 19 | const size_t testCount = sizeof(testCases) / sizeof(testCases[0]); 20 | 21 | DynamicJsonDocument doc(4096); 22 | 23 | for (size_t i = 0; i < testCount; i++) { 24 | const char* input = testCases[i]; 25 | CAPTURE(input); 26 | REQUIRE(deserializeJson(doc, input) == 27 | DeserializationError::IncompleteInput); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(JsonDocumentTests 6 | add.cpp 7 | BasicJsonDocument.cpp 8 | compare.cpp 9 | containsKey.cpp 10 | createNested.cpp 11 | DynamicJsonDocument.cpp 12 | isNull.cpp 13 | nesting.cpp 14 | remove.cpp 15 | shrinkToFit.cpp 16 | size.cpp 17 | StaticJsonDocument.cpp 18 | subscript.cpp 19 | ) 20 | 21 | add_test(JsonDocument JsonDocumentTests) 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/add.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonDocument::add()") { 9 | DynamicJsonDocument doc(4096); 10 | 11 | SECTION("integer") { 12 | doc.add(42); 13 | 14 | REQUIRE(doc.as() == "[42]"); 15 | } 16 | 17 | SECTION("const char*") { 18 | doc.add("hello"); 19 | 20 | REQUIRE(doc.as() == "[\"hello\"]"); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/containsKey.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonDocument::containsKey()") { 9 | DynamicJsonDocument doc(4096); 10 | 11 | SECTION("returns true on object") { 12 | doc["hello"] = "world"; 13 | 14 | REQUIRE(doc.containsKey("hello") == true); 15 | } 16 | 17 | SECTION("returns true when value is null") { 18 | doc["hello"] = static_cast(0); 19 | 20 | REQUIRE(doc.containsKey("hello") == true); 21 | } 22 | 23 | SECTION("returns true when key is a std::string") { 24 | doc["hello"] = "world"; 25 | 26 | REQUIRE(doc.containsKey(std::string("hello")) == true); 27 | } 28 | 29 | SECTION("returns false on object") { 30 | doc["world"] = "hello"; 31 | 32 | REQUIRE(doc.containsKey("hello") == false); 33 | } 34 | 35 | SECTION("returns false on array") { 36 | doc.add("hello"); 37 | 38 | REQUIRE(doc.containsKey("hello") == false); 39 | } 40 | 41 | SECTION("returns false on null") { 42 | REQUIRE(doc.containsKey("hello") == false); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/isNull.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonDocument::isNull()") { 9 | DynamicJsonDocument doc(4096); 10 | 11 | SECTION("returns true if uninitialized") { 12 | REQUIRE(doc.isNull() == true); 13 | } 14 | 15 | SECTION("returns false after to()") { 16 | doc.to(); 17 | REQUIRE(doc.isNull() == false); 18 | } 19 | 20 | SECTION("returns false after to()") { 21 | doc.to(); 22 | REQUIRE(doc.isNull() == false); 23 | } 24 | 25 | SECTION("returns true after to()") { 26 | REQUIRE(doc.isNull() == true); 27 | } 28 | 29 | SECTION("returns false after set()") { 30 | doc.to().set(42); 31 | REQUIRE(doc.isNull() == false); 32 | } 33 | 34 | SECTION("returns true after clear()") { 35 | doc.to(); 36 | doc.clear(); 37 | REQUIRE(doc.isNull() == true); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/nesting.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonDocument::nesting()") { 9 | DynamicJsonDocument doc(4096); 10 | 11 | SECTION("return 0 if uninitialized") { 12 | REQUIRE(doc.nesting() == 0); 13 | } 14 | 15 | SECTION("returns 0 for string") { 16 | JsonVariant var = doc.to(); 17 | var.set("hello"); 18 | REQUIRE(doc.nesting() == 0); 19 | } 20 | 21 | SECTION("returns 1 for empty object") { 22 | doc.to(); 23 | REQUIRE(doc.nesting() == 1); 24 | } 25 | 26 | SECTION("returns 1 for empty array") { 27 | doc.to(); 28 | REQUIRE(doc.nesting() == 1); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/remove.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonDocument::remove()") { 9 | DynamicJsonDocument doc(4096); 10 | 11 | SECTION("remove(int)") { 12 | doc.add(1); 13 | doc.add(2); 14 | doc.add(3); 15 | 16 | doc.remove(1); 17 | 18 | REQUIRE(doc.as() == "[1,3]"); 19 | } 20 | 21 | SECTION("remove(const char *)") { 22 | doc["a"] = 1; 23 | doc["b"] = 2; 24 | 25 | doc.remove("a"); 26 | 27 | REQUIRE(doc.as() == "{\"b\":2}"); 28 | } 29 | 30 | SECTION("remove(std::string)") { 31 | doc["a"] = 1; 32 | doc["b"] = 2; 33 | 34 | doc.remove(std::string("b")); 35 | 36 | REQUIRE(doc.as() == "{\"a\":1}"); 37 | } 38 | 39 | #ifdef HAS_VARIABLE_LENGTH_ARRAY 40 | SECTION("remove(vla)") { 41 | doc["a"] = 1; 42 | doc["b"] = 2; 43 | 44 | int i = 4; 45 | char vla[i]; 46 | strcpy(vla, "b"); 47 | doc.remove(vla); 48 | 49 | REQUIRE(doc.as() == "{\"a\":1}"); 50 | } 51 | #endif 52 | } 53 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonDocument/size.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonDocument::size()") { 9 | DynamicJsonDocument doc(4096); 10 | 11 | SECTION("returns 0") { 12 | REQUIRE(doc.size() == 0); 13 | } 14 | 15 | SECTION("as an array, return 2") { 16 | doc.add(1); 17 | doc.add(2); 18 | 19 | REQUIRE(doc.size() == 2); 20 | } 21 | 22 | SECTION("as an object, return 2") { 23 | doc["a"] = 1; 24 | doc["b"] = 2; 25 | 26 | REQUIRE(doc.size() == 2); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(JsonObjectTests 6 | containsKey.cpp 7 | copy.cpp 8 | createNestedArray.cpp 9 | createNestedObject.cpp 10 | equals.cpp 11 | invalid.cpp 12 | isNull.cpp 13 | iterator.cpp 14 | memoryUsage.cpp 15 | nesting.cpp 16 | remove.cpp 17 | size.cpp 18 | std_string.cpp 19 | subscript.cpp 20 | ) 21 | 22 | add_test(JsonObject JsonObjectTests) 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/containsKey.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonObject::containsKey()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonObject obj = doc.to(); 11 | obj["hello"] = 42; 12 | 13 | SECTION("returns true only if key is present") { 14 | REQUIRE(false == obj.containsKey("world")); 15 | REQUIRE(true == obj.containsKey("hello")); 16 | } 17 | 18 | SECTION("works with JsonObjectConst") { 19 | JsonObjectConst cobj = obj; 20 | REQUIRE(false == cobj.containsKey("world")); 21 | REQUIRE(true == cobj.containsKey("hello")); 22 | } 23 | 24 | SECTION("returns false after remove()") { 25 | obj.remove("hello"); 26 | 27 | REQUIRE(false == obj.containsKey("hello")); 28 | } 29 | 30 | #ifdef HAS_VARIABLE_LENGTH_ARRAY 31 | SECTION("key is a VLA") { 32 | int i = 16; 33 | char vla[i]; 34 | strcpy(vla, "hello"); 35 | 36 | REQUIRE(true == obj.containsKey(vla)); 37 | } 38 | #endif 39 | } 40 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/createNestedArray.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonObject::createNestedArray()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonObject obj = doc.to(); 11 | 12 | SECTION("key is a const char*") { 13 | JsonArray arr = obj.createNestedArray("hello"); 14 | REQUIRE(arr.isNull() == false); 15 | } 16 | 17 | #ifdef HAS_VARIABLE_LENGTH_ARRAY 18 | SECTION("key is a VLA") { 19 | int i = 16; 20 | char vla[i]; 21 | strcpy(vla, "hello"); 22 | 23 | JsonArray arr = obj.createNestedArray(vla); 24 | REQUIRE(arr.isNull() == false); 25 | } 26 | #endif 27 | } 28 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/createNestedObject.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonObject::createNestedObject()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonObject obj = doc.to(); 11 | 12 | SECTION("key is a const char*") { 13 | obj.createNestedObject("hello"); 14 | } 15 | 16 | #ifdef HAS_VARIABLE_LENGTH_ARRAY 17 | SECTION("key is a VLA") { 18 | int i = 16; 19 | char vla[i]; 20 | strcpy(vla, "hello"); 21 | 22 | obj.createNestedObject(vla); 23 | } 24 | #endif 25 | } 26 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/invalid.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace Catch::Matchers; 9 | 10 | TEST_CASE("JsonObject::invalid()") { 11 | JsonObject obj; 12 | 13 | SECTION("SubscriptFails") { 14 | REQUIRE(obj["key"].isNull()); 15 | } 16 | 17 | SECTION("AddFails") { 18 | obj["hello"] = "world"; 19 | REQUIRE(0 == obj.size()); 20 | } 21 | 22 | SECTION("CreateNestedArrayFails") { 23 | REQUIRE(obj.createNestedArray("hello").isNull()); 24 | } 25 | 26 | SECTION("CreateNestedObjectFails") { 27 | REQUIRE(obj.createNestedObject("world").isNull()); 28 | } 29 | 30 | SECTION("serialize to 'null'") { 31 | char buffer[32]; 32 | serializeJson(obj, buffer, sizeof(buffer)); 33 | REQUIRE_THAT(buffer, Equals("null")); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/memoryUsage.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | TEST_CASE("JsonObject::memoryUsage()") { 10 | DynamicJsonDocument doc(4096); 11 | JsonObject obj = doc.to(); 12 | 13 | SECTION("return 0 if uninitialized") { 14 | JsonObject unitialized; 15 | REQUIRE(unitialized.memoryUsage() == 0); 16 | } 17 | 18 | SECTION("JSON_OBJECT_SIZE(0) for empty object") { 19 | REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(0)); 20 | } 21 | 22 | SECTION("JSON_OBJECT_SIZE(1) after add") { 23 | obj["hello"] = 42; 24 | REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1)); 25 | } 26 | 27 | SECTION("includes the size of the key") { 28 | obj[std::string("hello")] = 42; 29 | REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1) + 6); 30 | } 31 | 32 | SECTION("includes the size of the nested array") { 33 | JsonArray nested = obj.createNestedArray("nested"); 34 | nested.add(42); 35 | REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1)); 36 | } 37 | 38 | SECTION("includes the size of the nested object") { 39 | JsonObject nested = obj.createNestedObject("nested"); 40 | nested["hello"] = "world"; 41 | REQUIRE(obj.memoryUsage() == 2 * JSON_OBJECT_SIZE(1)); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/nesting.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonObject::nesting()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonObject obj = doc.to(); 11 | 12 | SECTION("return 0 if uninitialized") { 13 | JsonObject unitialized; 14 | REQUIRE(unitialized.nesting() == 0); 15 | } 16 | 17 | SECTION("returns 1 for empty object") { 18 | REQUIRE(obj.nesting() == 1); 19 | } 20 | 21 | SECTION("returns 1 for flat object") { 22 | obj["hello"] = "world"; 23 | REQUIRE(obj.nesting() == 1); 24 | } 25 | 26 | SECTION("returns 2 with nested array") { 27 | obj.createNestedArray("nested"); 28 | REQUIRE(obj.nesting() == 2); 29 | } 30 | 31 | SECTION("returns 2 with nested object") { 32 | obj.createNestedObject("nested"); 33 | REQUIRE(obj.nesting() == 2); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonObject/size.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | TEST_CASE("JsonObject::size()") { 10 | DynamicJsonDocument doc(4096); 11 | JsonObject obj = doc.to(); 12 | 13 | SECTION("initial size is zero") { 14 | REQUIRE(0 == obj.size()); 15 | } 16 | 17 | SECTION("increases when values are added") { 18 | obj["hello"] = 42; 19 | REQUIRE(1 == obj.size()); 20 | } 21 | 22 | SECTION("decreases when values are removed") { 23 | obj["hello"] = 42; 24 | obj.remove("hello"); 25 | REQUIRE(0 == obj.size()); 26 | } 27 | 28 | SECTION("doesn't increase when the same key is added twice") { 29 | obj["hello"] = 1; 30 | obj["hello"] = 2; 31 | REQUIRE(1 == obj.size()); 32 | } 33 | 34 | SECTION("doesn't decrease when another key is removed") { 35 | obj["hello"] = 1; 36 | obj.remove("world"); 37 | REQUIRE(1 == obj.size()); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonSerializer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(JsonSerializerTests 6 | CustomWriter.cpp 7 | JsonArray.cpp 8 | JsonArrayPretty.cpp 9 | JsonObject.cpp 10 | JsonObjectPretty.cpp 11 | JsonVariant.cpp 12 | misc.cpp 13 | std_stream.cpp 14 | std_string.cpp 15 | ) 16 | 17 | add_test(JsonSerializer JsonSerializerTests) 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonSerializer/CustomWriter.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | class CustomWriter { 9 | public: 10 | CustomWriter() {} 11 | 12 | size_t write(uint8_t c) { 13 | _str.append(1, static_cast(c)); 14 | return 1; 15 | } 16 | 17 | size_t write(const uint8_t *s, size_t n) { 18 | _str.append(reinterpret_cast(s), n); 19 | return n; 20 | } 21 | 22 | const std::string &str() const { 23 | return _str; 24 | } 25 | 26 | private: 27 | CustomWriter(const CustomWriter &); // non-copiable 28 | CustomWriter &operator=(const CustomWriter &); 29 | 30 | std::string _str; 31 | }; 32 | 33 | TEST_CASE("CustomWriter") { 34 | DynamicJsonDocument doc(4096); 35 | JsonArray array = doc.to(); 36 | array.add(4); 37 | array.add(2); 38 | 39 | SECTION("serializeJson()") { 40 | CustomWriter writer; 41 | serializeJson(array, writer); 42 | 43 | REQUIRE("[4,2]" == writer.str()); 44 | } 45 | 46 | SECTION("serializeJsonPretty") { 47 | CustomWriter writer; 48 | serializeJsonPretty(array, writer); 49 | 50 | REQUIRE("[\r\n 4,\r\n 2\r\n]" == writer.str()); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonSerializer/misc.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | TEST_CASE("serializeJson(MemberProxy)") { 6 | DynamicJsonDocument doc(4096); 7 | deserializeJson(doc, "{\"hello\":42}"); 8 | JsonObject obj = doc.as(); 9 | std::string result; 10 | 11 | serializeJson(obj["hello"], result); 12 | 13 | REQUIRE(result == "42"); 14 | } 15 | 16 | TEST_CASE("serializeJson(ElementProxy)") { 17 | DynamicJsonDocument doc(4096); 18 | deserializeJson(doc, "[42]"); 19 | JsonArray arr = doc.as(); 20 | std::string result; 21 | 22 | serializeJson(arr[0], result); 23 | 24 | REQUIRE(result == "42"); 25 | } 26 | 27 | TEST_CASE("serializeJson(JsonVariantSubscript)") { 28 | DynamicJsonDocument doc(4096); 29 | deserializeJson(doc, "[42]"); 30 | JsonVariant var = doc.as(); 31 | std::string result; 32 | 33 | serializeJson(var[0], result); 34 | 35 | REQUIRE(result == "42"); 36 | } 37 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonSerializer/std_string.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("serialize JsonArray to std::string") { 9 | DynamicJsonDocument doc(4096); 10 | JsonArray array = doc.to(); 11 | array.add(4); 12 | array.add(2); 13 | 14 | SECTION("serializeJson()") { 15 | std::string json; 16 | serializeJson(array, json); 17 | 18 | REQUIRE("[4,2]" == json); 19 | } 20 | 21 | SECTION("serializeJsonPretty") { 22 | std::string json; 23 | serializeJsonPretty(array, json); 24 | 25 | REQUIRE("[\r\n 4,\r\n 2\r\n]" == json); 26 | } 27 | } 28 | 29 | TEST_CASE("serialize JsonObject to std::string") { 30 | DynamicJsonDocument doc(4096); 31 | JsonObject obj = doc.to(); 32 | obj["key"] = "value"; 33 | 34 | SECTION("object") { 35 | std::string json; 36 | serializeJson(doc, json); 37 | 38 | REQUIRE("{\"key\":\"value\"}" == json); 39 | } 40 | 41 | SECTION("serializeJsonPretty") { 42 | std::string json; 43 | serializeJsonPretty(doc, json); 44 | 45 | REQUIRE("{\r\n \"key\": \"value\"\r\n}" == json); 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(JsonVariantTests 6 | add.cpp 7 | as.cpp 8 | clear.cpp 9 | compare.cpp 10 | containsKey.cpp 11 | copy.cpp 12 | createNested.cpp 13 | is.cpp 14 | isnull.cpp 15 | memoryUsage.cpp 16 | misc.cpp 17 | nesting.cpp 18 | or.cpp 19 | overflow.cpp 20 | remove.cpp 21 | set.cpp 22 | subscript.cpp 23 | types.cpp 24 | undefined.cpp 25 | ) 26 | 27 | add_test(JsonVariant JsonVariantTests) 28 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/add.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | TEST_CASE("JsonVariant::add()") { 10 | DynamicJsonDocument doc(4096); 11 | JsonVariant var = doc.to(); 12 | 13 | SECTION("integer") { 14 | var.add(42); 15 | 16 | REQUIRE(var.as() == "[42]"); 17 | } 18 | 19 | SECTION("const char*") { 20 | var.add("hello"); 21 | 22 | REQUIRE(var.as() == "[\"hello\"]"); 23 | } 24 | 25 | SECTION("std::string") { 26 | var.add(std::string("hello")); 27 | 28 | REQUIRE(var.as() == "[\"hello\"]"); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/clear.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | TEST_CASE("JsonVariant::clear()") { 10 | DynamicJsonDocument doc(4096); 11 | JsonVariant var = doc.to(); 12 | 13 | SECTION("size goes back to zero") { 14 | var.add(42); 15 | var.clear(); 16 | 17 | REQUIRE(var.size() == 0); 18 | } 19 | 20 | SECTION("isNull() return true") { 21 | var.add("hello"); 22 | var.clear(); 23 | 24 | REQUIRE(var.isNull() == true); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/containsKey.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | static const char* null = 0; 10 | 11 | TEST_CASE("JsonVariant::containsKey()") { 12 | DynamicJsonDocument doc(4096); 13 | JsonVariant var = doc.to(); 14 | 15 | SECTION("containsKey(const char*) returns true") { 16 | var["hello"] = "world"; 17 | 18 | REQUIRE(var.containsKey("hello") == true); 19 | REQUIRE(var.containsKey("world") == false); 20 | } 21 | 22 | SECTION("containsKey(std::string) returns true") { 23 | var["hello"] = "world"; 24 | 25 | REQUIRE(var.containsKey(std::string("hello")) == true); 26 | REQUIRE(var.containsKey(std::string("world")) == false); 27 | } 28 | } 29 | 30 | TEST_CASE("JsonVariantConst::containsKey()") { 31 | DynamicJsonDocument doc(4096); 32 | doc["hello"] = "world"; 33 | JsonVariantConst cvar = doc.as(); 34 | 35 | SECTION("containsKey(const char*) returns true") { 36 | REQUIRE(cvar.containsKey("hello") == true); 37 | REQUIRE(cvar.containsKey("world") == false); 38 | } 39 | 40 | SECTION("containsKey(std::string) returns true") { 41 | REQUIRE(cvar.containsKey(std::string("hello")) == true); 42 | REQUIRE(cvar.containsKey(std::string("world")) == false); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/memoryUsage.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | TEST_CASE("JsonVariant::memoryUsage()") { 10 | DynamicJsonDocument doc(4096); 11 | JsonVariant var = doc.to(); 12 | 13 | SECTION("returns 0 if uninitialized") { 14 | JsonVariant unitialized; 15 | REQUIRE(unitialized.memoryUsage() == 0); 16 | } 17 | 18 | SECTION("returns size of object") { 19 | JsonObject obj = var.to(); 20 | obj["hello"] = 42; 21 | REQUIRE(var.memoryUsage() == JSON_OBJECT_SIZE(1)); 22 | } 23 | 24 | SECTION("returns size of array") { 25 | JsonArray arr = var.to(); 26 | arr.add(42); 27 | REQUIRE(var.memoryUsage() == JSON_ARRAY_SIZE(1)); 28 | } 29 | 30 | SECTION("returns size of owned string") { 31 | var.set(std::string("hello")); 32 | REQUIRE(var.memoryUsage() == 6); 33 | } 34 | 35 | SECTION("returns size of owned raw") { 36 | var.set(serialized(std::string("hello"))); 37 | REQUIRE(var.memoryUsage() == 5); 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/misc.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonVariant from JsonArray") { 9 | SECTION("JsonArray is null") { 10 | JsonArray arr; 11 | JsonVariant v = arr; 12 | REQUIRE(v.isNull() == true); 13 | } 14 | 15 | SECTION("JsonArray is not null") { 16 | DynamicJsonDocument doc(4096); 17 | JsonArray arr = doc.to(); 18 | arr.add(12); 19 | arr.add(34); 20 | 21 | JsonVariant v = arr; 22 | 23 | REQUIRE(v.is() == true); 24 | REQUIRE(v.size() == 2); 25 | REQUIRE(v[0] == 12); 26 | REQUIRE(v[1] == 34); 27 | } 28 | } 29 | 30 | TEST_CASE("JsonVariant from JsonObject") { 31 | SECTION("JsonObject is null") { 32 | JsonObject obj; 33 | JsonVariant v = obj; 34 | REQUIRE(v.isNull() == true); 35 | } 36 | 37 | SECTION("JsonObject is not null") { 38 | DynamicJsonDocument doc(4096); 39 | JsonObject obj = doc.to(); 40 | obj["a"] = 12; 41 | obj["b"] = 34; 42 | 43 | JsonVariant v = obj; 44 | 45 | REQUIRE(v.is() == true); 46 | REQUIRE(v.size() == 2); 47 | REQUIRE(v["a"] == 12); 48 | REQUIRE(v["b"] == 34); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/nesting.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonVariant::nesting()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonVariant var = doc.to(); 11 | 12 | SECTION("return 0 if uninitialized") { 13 | JsonVariant unitialized; 14 | REQUIRE(unitialized.nesting() == 0); 15 | } 16 | 17 | SECTION("returns 0 for string") { 18 | var.set("hello"); 19 | REQUIRE(var.nesting() == 0); 20 | } 21 | 22 | SECTION("returns 1 for empty object") { 23 | var.to(); 24 | REQUIRE(var.nesting() == 1); 25 | } 26 | 27 | SECTION("returns 1 for empty array") { 28 | var.to(); 29 | REQUIRE(var.nesting() == 1); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/JsonVariant/remove.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | static const char* null = 0; 10 | 11 | TEST_CASE("JsonVariant::remove()") { 12 | DynamicJsonDocument doc(4096); 13 | JsonVariant var = doc.to(); 14 | 15 | SECTION("remove(int)") { 16 | var.add(1); 17 | var.add(2); 18 | var.add(3); 19 | 20 | var.remove(1); 21 | 22 | REQUIRE(var.as() == "[1,3]"); 23 | } 24 | 25 | SECTION("remove(const char *)") { 26 | var["a"] = 1; 27 | var["b"] = 2; 28 | 29 | var.remove("a"); 30 | 31 | REQUIRE(var.as() == "{\"b\":2}"); 32 | } 33 | 34 | SECTION("remove(std::string)") { 35 | var["a"] = 1; 36 | var["b"] = 2; 37 | 38 | var.remove(std::string("b")); 39 | 40 | REQUIRE(var.as() == "{\"a\":1}"); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(MemberProxyTests 6 | add.cpp 7 | clear.cpp 8 | compare.cpp 9 | containsKey.cpp 10 | remove.cpp 11 | set.cpp 12 | size.cpp 13 | subscript.cpp 14 | ) 15 | 16 | add_test(MemberProxy MemberProxyTests) 17 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/add.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::add()") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("add(int)") { 15 | mp.add(42); 16 | 17 | REQUIRE(doc.as() == "{\"hello\":[42]}"); 18 | } 19 | 20 | SECTION("add(const char*)") { 21 | mp.add("world"); 22 | 23 | REQUIRE(doc.as() == "{\"hello\":[\"world\"]}"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/clear.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::clear()") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("size goes back to zero") { 15 | mp.add(42); 16 | mp.clear(); 17 | 18 | REQUIRE(mp.size() == 0); 19 | } 20 | 21 | SECTION("isNull() return true") { 22 | mp.add("hello"); 23 | mp.clear(); 24 | 25 | REQUIRE(mp.isNull() == true); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/compare.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::operator==()") { 11 | DynamicJsonDocument doc(4096); 12 | 13 | SECTION("1 vs 1") { 14 | doc["a"] = 1; 15 | doc["b"] = 1; 16 | 17 | REQUIRE(doc["a"] <= doc["b"]); 18 | REQUIRE(doc["a"] == doc["b"]); 19 | REQUIRE(doc["a"] >= doc["b"]); 20 | REQUIRE_FALSE(doc["a"] != doc["b"]); 21 | REQUIRE_FALSE(doc["a"] < doc["b"]); 22 | REQUIRE_FALSE(doc["a"] > doc["b"]); 23 | } 24 | 25 | SECTION("1 vs 2") { 26 | doc["a"] = 1; 27 | doc["b"] = 2; 28 | 29 | REQUIRE(doc["a"] != doc["b"]); 30 | REQUIRE(doc["a"] < doc["b"]); 31 | REQUIRE(doc["a"] <= doc["b"]); 32 | REQUIRE_FALSE(doc["a"] == doc["b"]); 33 | REQUIRE_FALSE(doc["a"] > doc["b"]); 34 | REQUIRE_FALSE(doc["a"] >= doc["b"]); 35 | } 36 | 37 | SECTION("'abc' vs 'bcd'") { 38 | doc["a"] = "abc"; 39 | doc["b"] = "bcd"; 40 | 41 | REQUIRE(doc["a"] != doc["b"]); 42 | REQUIRE(doc["a"] < doc["b"]); 43 | REQUIRE(doc["a"] <= doc["b"]); 44 | REQUIRE_FALSE(doc["a"] == doc["b"]); 45 | REQUIRE_FALSE(doc["a"] > doc["b"]); 46 | REQUIRE_FALSE(doc["a"] >= doc["b"]); 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/containsKey.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::containsKey()") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("containsKey(const char*)") { 15 | mp["key"] = "value"; 16 | 17 | REQUIRE(mp.containsKey("key") == true); 18 | REQUIRE(mp.containsKey("key") == true); 19 | } 20 | 21 | SECTION("containsKey(std::string)") { 22 | mp["key"] = "value"; 23 | 24 | REQUIRE(mp.containsKey(std::string("key")) == true); 25 | REQUIRE(mp.containsKey(std::string("key")) == true); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/remove.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::remove()") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("remove(int)") { 15 | mp.add(1); 16 | mp.add(2); 17 | mp.add(3); 18 | 19 | mp.remove(1); 20 | 21 | REQUIRE(mp.as() == "[1,3]"); 22 | } 23 | 24 | SECTION("remove(const char *)") { 25 | mp["a"] = 1; 26 | mp["b"] = 2; 27 | 28 | mp.remove("a"); 29 | 30 | REQUIRE(mp.as() == "{\"b\":2}"); 31 | } 32 | 33 | SECTION("remove(std::string)") { 34 | mp["a"] = 1; 35 | mp["b"] = 2; 36 | 37 | mp.remove(std::string("b")); 38 | 39 | REQUIRE(mp.as() == "{\"a\":1}"); 40 | } 41 | 42 | #ifdef HAS_VARIABLE_LENGTH_ARRAY 43 | SECTION("remove(vla)") { 44 | mp["a"] = 1; 45 | mp["b"] = 2; 46 | 47 | int i = 4; 48 | char vla[i]; 49 | strcpy(vla, "b"); 50 | mp.remove(vla); 51 | 52 | REQUIRE(mp.as() == "{\"a\":1}"); 53 | } 54 | #endif 55 | } 56 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/set.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::set()") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("set(int)") { 15 | mp.set(42); 16 | 17 | REQUIRE(doc.as() == "{\"hello\":42}"); 18 | } 19 | 20 | SECTION("set(const char*)") { 21 | mp.set("world"); 22 | 23 | REQUIRE(doc.as() == "{\"hello\":\"world\"}"); 24 | } 25 | 26 | SECTION("set(char[])") { // issue #1191 27 | char s[] = "world"; 28 | mp.set(s); 29 | strcpy(s, "!!!!!"); 30 | 31 | REQUIRE(doc.as() == "{\"hello\":\"world\"}"); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/size.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::size()") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("returns 0") { 15 | REQUIRE(mp.size() == 0); 16 | } 17 | 18 | SECTION("as an array, return 2") { 19 | mp.add(1); 20 | mp.add(2); 21 | 22 | REQUIRE(mp.size() == 2); 23 | } 24 | 25 | SECTION("as an object, return 2") { 26 | mp["a"] = 1; 27 | mp["b"] = 2; 28 | 29 | REQUIRE(mp.size() == 2); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemberProxy/subscript.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemberProxy::operator[]") { 11 | DynamicJsonDocument doc(4096); 12 | MemberProxy mp = doc["hello"]; 13 | 14 | SECTION("set member") { 15 | mp["world"] = 42; 16 | 17 | REQUIRE(doc.as() == "{\"hello\":{\"world\":42}}"); 18 | } 19 | 20 | SECTION("set element") { 21 | mp[2] = 42; 22 | 23 | REQUIRE(doc.as() == "{\"hello\":[null,null,42]}"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemoryPool/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(MemoryPoolTests 6 | allocVariant.cpp 7 | clear.cpp 8 | saveString.cpp 9 | size.cpp 10 | StringCopier.cpp 11 | ) 12 | 13 | add_test(MemoryPool MemoryPoolTests) 14 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemoryPool/allocVariant.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemoryPool::allocVariant()") { 11 | char buffer[4096]; 12 | 13 | SECTION("Returns different pointer") { 14 | MemoryPool pool(buffer, sizeof(buffer)); 15 | 16 | VariantSlot* s1 = pool.allocVariant(); 17 | REQUIRE(s1 != 0); 18 | VariantSlot* s2 = pool.allocVariant(); 19 | REQUIRE(s2 != 0); 20 | 21 | REQUIRE(s1 != s2); 22 | } 23 | 24 | SECTION("Returns aligned pointers") { 25 | MemoryPool pool(buffer, sizeof(buffer)); 26 | 27 | REQUIRE(isAligned(pool.allocVariant())); 28 | REQUIRE(isAligned(pool.allocVariant())); 29 | } 30 | 31 | SECTION("Returns zero if capacity is 0") { 32 | MemoryPool pool(buffer, 0); 33 | 34 | REQUIRE(pool.allocVariant() == 0); 35 | } 36 | 37 | SECTION("Returns zero if buffer is null") { 38 | MemoryPool pool(0, sizeof(buffer)); 39 | 40 | REQUIRE(pool.allocVariant() == 0); 41 | } 42 | 43 | SECTION("Returns zero if capacity is insufficient") { 44 | MemoryPool pool(buffer, sizeof(VariantSlot)); 45 | 46 | pool.allocVariant(); 47 | 48 | REQUIRE(pool.allocVariant() == 0); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemoryPool/clear.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace ARDUINOJSON_NAMESPACE; 10 | 11 | static const size_t poolCapacity = 512; 12 | 13 | TEST_CASE("MemoryPool::clear()") { 14 | char buffer[poolCapacity]; 15 | MemoryPool pool(buffer, sizeof(buffer)); 16 | 17 | SECTION("Discards allocated variants") { 18 | pool.allocVariant(); 19 | 20 | pool.clear(); 21 | REQUIRE(pool.size() == 0); 22 | } 23 | 24 | SECTION("Discards allocated strings") { 25 | pool.saveString(adaptString(const_cast("123456789"))); 26 | REQUIRE(pool.size() == 10); 27 | 28 | pool.clear(); 29 | 30 | REQUIRE(pool.size() == 0); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MemoryPool/size.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("MemoryPool::capacity()") { 11 | char buffer[4096]; 12 | const size_t capacity = 64; 13 | MemoryPool pool(buffer, capacity); 14 | REQUIRE(capacity == pool.capacity()); 15 | } 16 | 17 | TEST_CASE("MemoryPool::size()") { 18 | char buffer[4096]; 19 | MemoryPool pool(buffer, sizeof(buffer)); 20 | 21 | SECTION("Initial size is 0") { 22 | REQUIRE(0 == pool.size()); 23 | } 24 | 25 | SECTION("Doesn't grow when memory pool is full") { 26 | const size_t variantCount = sizeof(buffer) / sizeof(VariantSlot); 27 | 28 | for (size_t i = 0; i < variantCount; i++) pool.allocVariant(); 29 | size_t size = pool.size(); 30 | 31 | pool.allocVariant(); 32 | 33 | REQUIRE(size == pool.size()); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(MiscTests 6 | arithmeticCompare.cpp 7 | conflicts.cpp 8 | FloatParts.cpp 9 | JsonString.cpp 10 | Readers.cpp 11 | StringAdapters.cpp 12 | StringWriter.cpp 13 | TypeTraits.cpp 14 | unsigned_char.cpp 15 | Utf16.cpp 16 | Utf8.cpp 17 | version.cpp 18 | ) 19 | 20 | set_target_properties(MiscTests PROPERTIES UNITY_BUILD OFF) 21 | 22 | add_test(Misc MiscTests) 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/FloatParts.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("FloatParts") { 11 | SECTION("1.7976931348623157E+308") { 12 | FloatParts parts(1.7976931348623157E+308); 13 | REQUIRE(parts.integral == 1); 14 | REQUIRE(parts.decimal == 797693135); 15 | REQUIRE(parts.decimalPlaces == 9); 16 | REQUIRE(parts.exponent == 308); 17 | } 18 | 19 | SECTION("4.94065645841247e-324") { 20 | FloatParts parts(4.94065645841247e-324); 21 | REQUIRE(parts.integral == 4); 22 | REQUIRE(parts.decimal == 940656458); 23 | REQUIRE(parts.decimalPlaces == 9); 24 | REQUIRE(parts.exponent == -324); 25 | } 26 | } 27 | 28 | TEST_CASE("FloatParts") { 29 | SECTION("3.4E+38") { 30 | FloatParts parts(3.4E+38f); 31 | REQUIRE(parts.integral == 3); 32 | REQUIRE(parts.decimal == 4); 33 | REQUIRE(parts.decimalPlaces == 1); 34 | REQUIRE(parts.exponent == 38); 35 | } 36 | 37 | SECTION("1.17549435e−38") { 38 | FloatParts parts(1.17549435e-38f); 39 | REQUIRE(parts.integral == 1); 40 | REQUIRE(parts.decimal == 175494); 41 | REQUIRE(parts.decimalPlaces == 6); 42 | REQUIRE(parts.exponent == -38); 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/JsonString.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("JsonString") { 9 | SECTION("Default constructor creates a null JsonString") { 10 | JsonString s; 11 | 12 | CHECK(s.isNull() == true); 13 | CHECK(s.c_str() == 0); 14 | CHECK(s.isStatic() == true); 15 | } 16 | 17 | SECTION("Compare null with null") { 18 | JsonString a, b; 19 | 20 | CHECK(a == b); 21 | CHECK_FALSE(a != b); 22 | } 23 | 24 | SECTION("Compare null with non-null") { 25 | JsonString a(0), b("hello"); 26 | 27 | CHECK_FALSE(a == b); 28 | CHECK(a != b); 29 | } 30 | 31 | SECTION("Compare non-null with null") { 32 | JsonString a("hello"), b(0); 33 | 34 | CHECK_FALSE(a == b); 35 | CHECK(a != b); 36 | } 37 | 38 | SECTION("Compare different strings") { 39 | JsonString a("hello"), b("world"); 40 | 41 | CHECK_FALSE(a == b); 42 | CHECK(a != b); 43 | } 44 | 45 | SECTION("Compare identical by pointer") { 46 | JsonString a("hello"), b("hello"); 47 | 48 | CHECK(a == b); 49 | CHECK_FALSE(a != b); 50 | } 51 | 52 | SECTION("Compare identical by value") { 53 | char s1[] = "hello"; 54 | char s2[] = "hello"; 55 | JsonString a(s1), b(s2); 56 | 57 | CHECK(a == b); 58 | CHECK_FALSE(a != b); 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/Utf8.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | #include 9 | 10 | using namespace ARDUINOJSON_NAMESPACE; 11 | 12 | static void testCodepoint(uint32_t codepoint, std::string expected) { 13 | char buffer[4096]; 14 | MemoryPool pool(buffer, 4096); 15 | StringCopier str; 16 | str.startString(&pool); 17 | 18 | CAPTURE(codepoint); 19 | Utf8::encodeCodepoint(codepoint, str); 20 | 21 | str.append('\0'); 22 | REQUIRE(str.c_str() == expected); 23 | } 24 | 25 | TEST_CASE("Utf8::encodeCodepoint()") { 26 | SECTION("U+0000") { 27 | testCodepoint(0x0000, ""); 28 | } 29 | 30 | SECTION("U+0001") { 31 | testCodepoint(0x0001, "\x01"); 32 | } 33 | 34 | SECTION("U+007F") { 35 | testCodepoint(0x007F, "\x7f"); 36 | } 37 | 38 | SECTION("U+0080") { 39 | testCodepoint(0x0080, "\xc2\x80"); 40 | } 41 | 42 | SECTION("U+07FF") { 43 | testCodepoint(0x07FF, "\xdf\xbf"); 44 | } 45 | 46 | SECTION("U+0800") { 47 | testCodepoint(0x0800, "\xe0\xa0\x80"); 48 | } 49 | 50 | SECTION("U+FFFF") { 51 | testCodepoint(0xFFFF, "\xef\xbf\xbf"); 52 | } 53 | 54 | SECTION("U+10000") { 55 | testCodepoint(0x10000, "\xf0\x90\x80\x80"); 56 | } 57 | 58 | SECTION("U+10FFFF") { 59 | testCodepoint(0x10FFFF, "\xf4\x8f\xbf\xbf"); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/conflicts.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | // Include any header that might use the conflicting macros 6 | #include 7 | #include 8 | #include 9 | 10 | // All cores 11 | #define bit() 12 | #define constrain() 13 | #define DEFAULT 14 | #define DISABLED 15 | #define HIGH 16 | #define INPUT 17 | #define LOW 18 | #define max() 19 | #define min() 20 | #define OUTPUT 21 | #define round() 22 | #define sq() 23 | #define word() 24 | #define bitRead() 25 | #define bitSet() 26 | #define bitClear() 27 | #define bitWrite() 28 | #define interrupts() 29 | #define lowByte() 30 | #define highByte() 31 | #define DEC 32 | #define HEX 33 | #define OCT 34 | #define BIN 35 | #define cbi() 36 | #define sbi() 37 | 38 | // ESP8266 39 | #define _max() 40 | #define _min() 41 | 42 | // issue #839 43 | #define BLOCKSIZE 44 | #define CAPACITY 45 | 46 | // catch.hpp mutes several warnings, this file also allows to detect them 47 | #include "ArduinoJson.h" 48 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/custom_string.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | struct custom_char_traits : std::char_traits {}; 10 | struct custom_allocator : std::allocator {}; 11 | typedef std::basic_string 12 | custom_string; 13 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/version.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | using Catch::Matchers::StartsWith; 10 | 11 | TEST_CASE("ARDUINOJSON_VERSION") { 12 | std::stringstream version; 13 | 14 | version << ARDUINOJSON_VERSION_MAJOR << "." << ARDUINOJSON_VERSION_MINOR 15 | << "." << ARDUINOJSON_VERSION_REVISION; 16 | 17 | REQUIRE_THAT(ARDUINOJSON_VERSION, StartsWith(version.str())); 18 | } 19 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Misc/weird_strcmp.hpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | // Issue #1198: strcmp() implementation that returns a value larger than 8-bit 4 | 5 | namespace ARDUINOJSON_NAMESPACE { 6 | int strcmp(const char* a, const char* b) { 7 | int result = ::strcmp(a, b); 8 | if (result > 0) 9 | return 2147483647; 10 | if (result < 0) 11 | return -214748364; 12 | return 0; 13 | } 14 | 15 | int strncmp(const char* a, const char* b, size_t n) { 16 | int result = ::strncmp(a, b, n); 17 | if (result > 0) 18 | return 2147483647; 19 | if (result < 0) 20 | return -214748364; 21 | return 0; 22 | } 23 | } // namespace ARDUINOJSON_NAMESPACE 24 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | # we need C++11 for 'long long' 6 | set(CMAKE_CXX_STANDARD 11) 7 | 8 | add_executable(MixedConfigurationTests 9 | cpp11.cpp 10 | decode_unicode_0.cpp 11 | decode_unicode_1.cpp 12 | enable_alignment_0.cpp 13 | enable_alignment_1.cpp 14 | enable_comments_0.cpp 15 | enable_comments_1.cpp 16 | enable_infinity_0.cpp 17 | enable_infinity_1.cpp 18 | enable_nan_0.cpp 19 | enable_nan_1.cpp 20 | enable_progmem_1.cpp 21 | enable_string_deduplication_0.cpp 22 | enable_string_deduplication_1.cpp 23 | use_double_0.cpp 24 | use_double_1.cpp 25 | use_long_long_0.cpp 26 | use_long_long_1.cpp 27 | ) 28 | 29 | set_target_properties(MixedConfigurationTests PROPERTIES UNITY_BUILD OFF) 30 | 31 | add_test(MixedConfiguration MixedConfigurationTests) 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/decode_unicode_0.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_DECODE_UNICODE 0 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_DECODE_UNICODE == 0") { 7 | DynamicJsonDocument doc(2048); 8 | DeserializationError err = deserializeJson(doc, "\"\\uD834\\uDD1E\""); 9 | 10 | REQUIRE(err == DeserializationError::NotSupported); 11 | } 12 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/decode_unicode_1.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_DECODE_UNICODE 1 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_DECODE_UNICODE == 1") { 7 | DynamicJsonDocument doc(2048); 8 | DeserializationError err = deserializeJson(doc, "\"\\uD834\\uDD1E\""); 9 | 10 | REQUIRE(err == DeserializationError::Ok); 11 | } 12 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/enable_alignment_0.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_NAMESPACE ArduinoJson_NoAlignment 2 | #define ARDUINOJSON_ENABLE_ALIGNMENT 0 3 | #include 4 | 5 | #include 6 | 7 | TEST_CASE("ARDUINOJSON_ENABLE_ALIGNMENT == 0") { 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | const size_t N = sizeof(void*); 11 | 12 | SECTION("isAligned()") { 13 | CHECK(isAligned(0) == true); 14 | CHECK(isAligned(1) == true); 15 | CHECK(isAligned(N) == true); 16 | CHECK(isAligned(N + 1) == true); 17 | CHECK(isAligned(2 * N) == true); 18 | CHECK(isAligned(2 * N + 1) == true); 19 | } 20 | 21 | SECTION("addPadding()") { 22 | CHECK(addPadding(0) == 0); 23 | CHECK(addPadding(1) == 1); 24 | CHECK(addPadding(N) == N); 25 | CHECK(addPadding(N + 1) == N + 1); 26 | } 27 | 28 | SECTION("AddPadding<>") { 29 | const size_t a = AddPadding<0>::value; 30 | CHECK(a == 0); 31 | 32 | const size_t b = AddPadding<1>::value; 33 | CHECK(b == 1); 34 | 35 | const size_t c = AddPadding::value; 36 | CHECK(c == N); 37 | 38 | const size_t d = AddPadding::value; 39 | CHECK(d == N + 1); 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/enable_alignment_1.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_ENABLE_ALIGNMENT 1 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_ENABLE_ALIGNMENT == 1") { 7 | using namespace ARDUINOJSON_NAMESPACE; 8 | 9 | const size_t N = sizeof(void*); 10 | 11 | SECTION("isAligned()") { 12 | CHECK(isAligned(0) == true); 13 | CHECK(isAligned(1) == false); 14 | CHECK(isAligned(N) == true); 15 | CHECK(isAligned(N + 1) == false); 16 | CHECK(isAligned(2 * N) == true); 17 | CHECK(isAligned(2 * N + 1) == false); 18 | } 19 | 20 | SECTION("addPadding()") { 21 | CHECK(addPadding(0) == 0); 22 | CHECK(addPadding(1) == N); 23 | CHECK(addPadding(N) == N); 24 | CHECK(addPadding(N + 1) == 2 * N); 25 | } 26 | 27 | SECTION("AddPadding<>") { 28 | const size_t a = AddPadding<0>::value; 29 | CHECK(a == 0); 30 | 31 | const size_t b = AddPadding<1>::value; 32 | CHECK(b == N); 33 | 34 | const size_t c = AddPadding::value; 35 | CHECK(c == N); 36 | 37 | const size_t d = AddPadding::value; 38 | CHECK(d == 2 * N); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/enable_infinity_0.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_ENABLE_INFINITY 0 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | static void assertParseFails(const char* json) { 8 | DynamicJsonDocument doc(4096); 9 | auto err = deserializeJson(doc, json); 10 | 11 | REQUIRE(err == DeserializationError::InvalidInput); 12 | } 13 | 14 | static void assertJsonEquals(const JsonDocument& doc, 15 | std::string expectedJson) { 16 | std::string actualJson; 17 | serializeJson(doc, actualJson); 18 | REQUIRE(actualJson == expectedJson); 19 | } 20 | 21 | TEST_CASE("ARDUINOJSON_ENABLE_INFINITY == 0") { 22 | SECTION("serializeJson()") { 23 | DynamicJsonDocument doc(4096); 24 | doc.add(std::numeric_limits::infinity()); 25 | doc.add(-std::numeric_limits::infinity()); 26 | 27 | assertJsonEquals(doc, "[null,null]"); 28 | } 29 | 30 | SECTION("deserializeJson()") { 31 | assertParseFails("{\"X\":Infinity}"); 32 | assertParseFails("{\"X\":-Infinity}"); 33 | assertParseFails("{\"X\":+Infinity}"); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/enable_infinity_1.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_ENABLE_INFINITY 1 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | namespace my { 8 | using ARDUINOJSON_NAMESPACE::isinf; 9 | } // namespace my 10 | 11 | TEST_CASE("ARDUINOJSON_ENABLE_INFINITY == 1") { 12 | DynamicJsonDocument doc(4096); 13 | 14 | SECTION("serializeJson()") { 15 | doc.add(std::numeric_limits::infinity()); 16 | doc.add(-std::numeric_limits::infinity()); 17 | 18 | std::string json; 19 | serializeJson(doc, json); 20 | 21 | REQUIRE(json == "[Infinity,-Infinity]"); 22 | } 23 | 24 | SECTION("deserializeJson()") { 25 | auto err = deserializeJson(doc, "[Infinity,-Infinity,+Infinity]"); 26 | float a = doc[0]; 27 | float b = doc[1]; 28 | float c = doc[2]; 29 | 30 | REQUIRE(err == DeserializationError::Ok); 31 | REQUIRE(my::isinf(a)); 32 | REQUIRE(a > 0); 33 | REQUIRE(my::isinf(b)); 34 | REQUIRE(b < 0); 35 | REQUIRE(my::isinf(c)); 36 | REQUIRE(c > 0); 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/enable_nan_0.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_ENABLE_NAN 0 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | TEST_CASE("ARDUINOJSON_ENABLE_NAN == 0") { 8 | DynamicJsonDocument doc(4096); 9 | JsonObject root = doc.to(); 10 | 11 | SECTION("serializeJson()") { 12 | root["X"] = std::numeric_limits::signaling_NaN(); 13 | 14 | std::string json; 15 | serializeJson(doc, json); 16 | 17 | REQUIRE(json == "{\"X\":null}"); 18 | } 19 | 20 | SECTION("deserializeJson()") { 21 | auto err = deserializeJson(doc, "{\"X\":NaN}"); 22 | 23 | REQUIRE(err == DeserializationError::InvalidInput); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/enable_nan_1.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_ENABLE_NAN 1 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | namespace my { 8 | using ARDUINOJSON_NAMESPACE::isnan; 9 | } // namespace my 10 | 11 | TEST_CASE("ARDUINOJSON_ENABLE_NAN == 1") { 12 | DynamicJsonDocument doc(4096); 13 | JsonObject root = doc.to(); 14 | 15 | SECTION("serializeJson()") { 16 | root["X"] = std::numeric_limits::signaling_NaN(); 17 | 18 | std::string json; 19 | serializeJson(doc, json); 20 | 21 | REQUIRE(json == "{\"X\":NaN}"); 22 | } 23 | 24 | SECTION("deserializeJson()") { 25 | auto err = deserializeJson(doc, "{\"X\":NaN}"); 26 | float x = doc["X"]; 27 | 28 | REQUIRE(err == DeserializationError::Ok); 29 | REQUIRE(my::isnan(x)); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/use_double_0.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_USE_DOUBLE 0 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_USE_DOUBLE == 0") { 7 | DynamicJsonDocument doc(4096); 8 | JsonObject root = doc.to(); 9 | 10 | root["pi"] = 3.14; 11 | root["e"] = 2.72; 12 | 13 | std::string json; 14 | serializeJson(doc, json); 15 | 16 | REQUIRE(json == "{\"pi\":3.14,\"e\":2.72}"); 17 | } 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/use_double_1.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_USE_DOUBLE 1 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_USE_DOUBLE == 1") { 7 | DynamicJsonDocument doc(4096); 8 | JsonObject root = doc.to(); 9 | 10 | root["pi"] = 3.14; 11 | root["e"] = 2.72; 12 | 13 | std::string json; 14 | serializeJson(doc, json); 15 | 16 | REQUIRE(json == "{\"pi\":3.14,\"e\":2.72}"); 17 | } 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/use_long_long_0.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_USE_LONG_LONG 0 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_USE_LONG_LONG == 0") { 7 | DynamicJsonDocument doc(4096); 8 | 9 | doc["A"] = 42; 10 | doc["B"] = 84; 11 | 12 | std::string json; 13 | serializeJson(doc, json); 14 | 15 | REQUIRE(json == "{\"A\":42,\"B\":84}"); 16 | } 17 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MixedConfiguration/use_long_long_1.cpp: -------------------------------------------------------------------------------- 1 | #define ARDUINOJSON_USE_LONG_LONG 1 2 | #include 3 | 4 | #include 5 | 6 | TEST_CASE("ARDUINOJSON_USE_LONG_LONG == 1") { 7 | DynamicJsonDocument doc(4096); 8 | JsonObject root = doc.to(); 9 | 10 | root["A"] = 123456789123456789; 11 | root["B"] = 987654321987654321; 12 | 13 | std::string json; 14 | serializeJson(doc, json); 15 | 16 | REQUIRE(json == "{\"A\":123456789123456789,\"B\":987654321987654321}"); 17 | } 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MsgPackDeserializer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(MsgPackDeserializerTests 6 | deserializeArray.cpp 7 | deserializeObject.cpp 8 | deserializeStaticVariant.cpp 9 | deserializeVariant.cpp 10 | doubleToFloat.cpp 11 | incompleteInput.cpp 12 | input_types.cpp 13 | nestingLimit.cpp 14 | notSupported.cpp 15 | ) 16 | 17 | add_test(MsgPackDeserializer MsgPackDeserializerTests) 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MsgPackDeserializer/doubleToFloat.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | template 11 | static void check(const char* input, T expected) { 12 | T actual; 13 | uint8_t* f = reinterpret_cast(&actual); 14 | const uint8_t* d = reinterpret_cast(input); 15 | doubleToFloat(d, f); 16 | fixEndianess(actual); 17 | CHECK(actual == expected); 18 | } 19 | 20 | TEST_CASE("doubleToFloat()") { 21 | check("\x40\x09\x21\xCA\xC0\x83\x12\x6F", 3.1415f); 22 | check("\x00\x00\x00\x00\x00\x00\x00\x00", 0.0f); 23 | check("\x80\x00\x00\x00\x00\x00\x00\x00", -0.0f); 24 | check("\xC0\x5E\xDC\xCC\xCC\xCC\xCC\xCD", -123.45f); 25 | } 26 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MsgPackSerializer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(MsgPackSerializerTests 6 | destination_types.cpp 7 | measure.cpp 8 | misc.cpp 9 | serializeArray.cpp 10 | serializeObject.cpp 11 | serializeVariant.cpp 12 | ) 13 | 14 | add_test(MsgPackSerializer MsgPackSerializerTests) 15 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MsgPackSerializer/measure.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | TEST_CASE("measureMsgPack()") { 9 | DynamicJsonDocument doc(4096); 10 | JsonObject object = doc.to(); 11 | object["hello"] = "world"; 12 | 13 | REQUIRE(measureMsgPack(doc) == 13); 14 | } 15 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/MsgPackSerializer/misc.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | template 6 | void check(T value, const std::string &expected) { 7 | DynamicJsonDocument doc(4096); 8 | doc.to().set(value); 9 | char buffer[256] = ""; 10 | size_t returnValue = serializeMsgPack(doc, buffer, sizeof(buffer)); 11 | REQUIRE(expected == buffer); 12 | REQUIRE(expected.size() == returnValue); 13 | } 14 | 15 | TEST_CASE("serializeMsgPack(MemberProxy)") { 16 | DynamicJsonDocument doc(4096); 17 | deserializeJson(doc, "{\"hello\":42}"); 18 | JsonObject obj = doc.as(); 19 | std::string result; 20 | 21 | serializeMsgPack(obj["hello"], result); 22 | 23 | REQUIRE(result == "*"); 24 | } 25 | 26 | TEST_CASE("serializeMsgPack(ElementProxy)") { 27 | DynamicJsonDocument doc(4096); 28 | deserializeJson(doc, "[42]"); 29 | JsonArray arr = doc.as(); 30 | std::string result; 31 | 32 | serializeMsgPack(arr[0], result); 33 | 34 | REQUIRE(result == "*"); 35 | } 36 | 37 | TEST_CASE("serializeMsgPack(JsonVariantSubscript)") { 38 | DynamicJsonDocument doc(4096); 39 | deserializeJson(doc, "[42]"); 40 | JsonVariant var = doc.as(); 41 | std::string result; 42 | 43 | serializeMsgPack(var[0], result); 44 | 45 | REQUIRE(result == "*"); 46 | } 47 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Numbers/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(NumbersTests 6 | parseFloat.cpp 7 | parseInteger.cpp 8 | parseNumber.cpp 9 | ) 10 | 11 | 12 | add_test(Numbers NumbersTests) 13 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/Numbers/parseNumber.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #include 6 | #include 7 | 8 | using namespace ARDUINOJSON_NAMESPACE; 9 | 10 | TEST_CASE("Test uint32_t overflow") { 11 | ParsedNumber first, second; 12 | parseNumber("4294967295", first); 13 | parseNumber("4294967296", second); 14 | 15 | REQUIRE(first.type() == uint8_t(VALUE_IS_POSITIVE_INTEGER)); 16 | REQUIRE(second.type() == uint8_t(VALUE_IS_FLOAT)); 17 | } 18 | 19 | TEST_CASE("Invalid value") { 20 | ParsedNumber result; 21 | parseNumber("6a3", result); 22 | 23 | REQUIRE(result.type() == uint8_t(VALUE_IS_NULL)); 24 | } 25 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/TextFormatter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_executable(TextFormatterTests 6 | writeFloat.cpp 7 | writeString.cpp 8 | ) 9 | 10 | set_target_properties(TextFormatterTests PROPERTIES UNITY_BUILD OFF) 11 | 12 | add_test(TextFormatter TextFormatterTests) 13 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/catch/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # ArduinoJson - arduinojson.org 2 | # Copyright Benoit Blanchon 2014-2020 3 | # MIT License 4 | 5 | add_library(catch 6 | catch.hpp 7 | catch.cpp 8 | ) 9 | 10 | target_include_directories(catch 11 | PUBLIC 12 | ${CMAKE_CURRENT_SOURCE_DIR} 13 | ) 14 | 15 | if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") 16 | # prevent "xxx will change in GCC x.x" with arm-linux-gnueabihf-gcc 17 | target_compile_options(catch PRIVATE -Wno-psabi) 18 | endif() 19 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/extras/tests/catch/catch.cpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #define CATCH_CONFIG_MAIN 6 | #include "catch.hpp" 7 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/keywords.txt: -------------------------------------------------------------------------------- 1 | # Macros 2 | JSON_ARRAY_SIZE KEYWORD2 3 | JSON_OBJECT_SIZE KEYWORD2 4 | JSON_STRING_SIZE KEYWORD2 5 | 6 | # Free functions 7 | deserializeJson KEYWORD2 8 | deserializeMsgPack KEYWORD2 9 | serialized KEYWORD2 10 | serializeJson KEYWORD2 11 | serializeJsonPretty KEYWORD2 12 | serializeMsgPack KEYWORD2 13 | measureJson KEYWORD2 14 | measureJsonPretty KEYWORD2 15 | measureMsgPack KEYWORD2 16 | 17 | # Methods 18 | add KEYWORD2 19 | as KEYWORD2 20 | createNestedArray KEYWORD2 21 | createNestedObject KEYWORD2 22 | get KEYWORD2 23 | set KEYWORD2 24 | to KEYWORD2 25 | 26 | # Type names 27 | DeserializationError KEYWORD1 DATA_TYPE 28 | DynamicJsonDocument KEYWORD1 DATA_TYPE 29 | JsonArray KEYWORD1 DATA_TYPE 30 | JsonArrayConst KEYWORD1 DATA_TYPE 31 | JsonFloat KEYWORD1 DATA_TYPE 32 | JsonInteger KEYWORD1 DATA_TYPE 33 | JsonObject KEYWORD1 DATA_TYPE 34 | JsonObjectConst KEYWORD1 DATA_TYPE 35 | JsonString KEYWORD1 DATA_TYPE 36 | JsonUInt KEYWORD1 DATA_TYPE 37 | JsonVariant KEYWORD1 DATA_TYPE 38 | JsonVariantConst KEYWORD1 DATA_TYPE 39 | StaticJsonDocument KEYWORD1 DATA_TYPE 40 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/library.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "ArduinoJson", 3 | "keywords": "json, rest, http, web", 4 | "description": "A simple and efficient JSON library for embedded C++. ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, ✔ filtering, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation.", 5 | "homepage": "https://arduinojson.org/?utm_source=meta&utm_medium=library.json", 6 | "repository": { 7 | "type": "git", 8 | "url": "https://github.com/bblanchon/ArduinoJson.git" 9 | }, 10 | "version": "6.16.1", 11 | "authors": { 12 | "name": "Benoit Blanchon", 13 | "url": "https://blog.benoitblanchon.fr" 14 | }, 15 | "exclude": [ 16 | ".github", 17 | "extras" 18 | ], 19 | "frameworks": "arduino", 20 | "platforms": "*" 21 | } 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/library.properties: -------------------------------------------------------------------------------- 1 | name=ArduinoJson 2 | version=6.16.1 3 | author=Benoit Blanchon 4 | maintainer=Benoit Blanchon 5 | sentence=A simple and efficient JSON library for embedded C++. 6 | paragraph=ArduinoJson supports ✔ serialization, ✔ deserialization, ✔ MessagePack, ✔ fixed allocation, ✔ zero-copy, ✔ streams, ✔ filtering, and more. It is the most popular Arduino library on GitHub ❤❤❤❤❤. Check out arduinojson.org for a comprehensive documentation. 7 | category=Data Processing 8 | url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties 9 | architectures=* 10 | repository=https://github.com/bblanchon/ArduinoJson.git 11 | license=MIT 12 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson.h: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #ifdef __cplusplus 8 | 9 | #include "ArduinoJson.hpp" 10 | 11 | using namespace ArduinoJson; 12 | 13 | #else 14 | 15 | #error ArduinoJson requires a C++ compiler, please change file extension to .cc or .cpp 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Array/ArrayFunctions.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | inline VariantData *arrayAdd(CollectionData *arr, MemoryPool *pool) { 12 | return arr ? arr->addElement(pool) : 0; 13 | } 14 | 15 | template 16 | inline void arrayAccept(const CollectionData *arr, Visitor &visitor) { 17 | if (arr) 18 | visitor.visitArray(*arr); 19 | else 20 | visitor.visitNull(); 21 | } 22 | 23 | inline bool arrayEquals(const CollectionData *lhs, const CollectionData *rhs) { 24 | if (lhs == rhs) 25 | return true; 26 | if (!lhs || !rhs) 27 | return false; 28 | return lhs->equalsArray(*rhs); 29 | } 30 | } // namespace ARDUINOJSON_NAMESPACE 31 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Array/ArrayImpl.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | inline ArrayRef ArrayShortcuts::createNestedArray() const { 14 | return impl()->addElement().template to(); 15 | } 16 | 17 | template 18 | inline ObjectRef ArrayShortcuts::createNestedObject() const { 19 | return impl()->addElement().template to(); 20 | } 21 | 22 | template 23 | inline ElementProxy ArrayShortcuts::operator[]( 24 | size_t index) const { 25 | return ElementProxy(*impl(), index); 26 | } 27 | 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Deserialization/NestingLimit.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | class NestingLimit { 13 | public: 14 | NestingLimit() : _value(ARDUINOJSON_DEFAULT_NESTING_LIMIT) {} 15 | explicit NestingLimit(uint8_t n) : _value(n) {} 16 | 17 | NestingLimit decrement() const { 18 | ARDUINOJSON_ASSERT(_value > 0); 19 | return NestingLimit(static_cast(_value - 1)); 20 | } 21 | 22 | bool reached() const { 23 | return _value == 0; 24 | } 25 | 26 | private: 27 | uint8_t _value; 28 | }; 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStreamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct Reader::value>::type> { 14 | public: 15 | explicit Reader(Stream& stream) : _stream(&stream) {} 16 | 17 | int read() { 18 | // don't use _stream.read() as it ignores the timeout 19 | char c; 20 | return _stream->readBytes(&c, 1) ? static_cast(c) : -1; 21 | } 22 | 23 | size_t readBytes(char* buffer, size_t length) { 24 | return _stream->readBytes(buffer, length); 25 | } 26 | 27 | private: 28 | Stream* _stream; 29 | }; 30 | 31 | } // namespace ARDUINOJSON_NAMESPACE 32 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Deserialization/Readers/ArduinoStringReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | struct Reader::value>::type> 12 | : BoundedReader { 13 | explicit Reader(const ::String& s) 14 | : BoundedReader(s.c_str(), s.length()) {} 15 | }; 16 | 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Deserialization/Readers/IteratorReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | class IteratorReader { 11 | TIterator _ptr, _end; 12 | 13 | public: 14 | explicit IteratorReader(TIterator begin, TIterator end) 15 | : _ptr(begin), _end(end) {} 16 | 17 | int read() { 18 | if (_ptr < _end) 19 | return static_cast(*_ptr++); 20 | else 21 | return -1; 22 | } 23 | 24 | size_t readBytes(char* buffer, size_t length) { 25 | size_t i = 0; 26 | while (i < length && _ptr < _end) buffer[i++] = *_ptr++; 27 | return i; 28 | } 29 | }; 30 | 31 | template 32 | struct void_ { 33 | typedef void type; 34 | }; 35 | 36 | template 37 | struct Reader::type> 38 | : IteratorReader { 39 | explicit Reader(const TSource& source) 40 | : IteratorReader(source.begin(), 41 | source.end()) {} 42 | }; 43 | } // namespace ARDUINOJSON_NAMESPACE 44 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Deserialization/Readers/StdStreamReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct Reader::value>::type> { 14 | public: 15 | explicit Reader(std::istream& stream) : _stream(&stream) {} 16 | 17 | int read() { 18 | return _stream->get(); 19 | } 20 | 21 | size_t readBytes(char* buffer, size_t length) { 22 | _stream->read(buffer, static_cast(length)); 23 | return static_cast(_stream->gcount()); 24 | } 25 | 26 | private: 27 | std::istream* _stream; 28 | }; 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Deserialization/Readers/VariantReader.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | struct Reader, void> : Reader { 14 | explicit Reader(const ElementProxy& x) 15 | : Reader(x.template as()) {} 16 | }; 17 | 18 | template 19 | struct Reader, void> : Reader { 20 | explicit Reader(const MemberProxy& x) 21 | : Reader(x.template as()) {} 22 | }; 23 | 24 | template <> 25 | struct Reader : Reader { 26 | explicit Reader(VariantRef x) : Reader(x.as()) {} 27 | }; 28 | 29 | template <> 30 | struct Reader : Reader { 31 | explicit Reader(VariantConstRef x) 32 | : Reader(x.as()) {} 33 | }; 34 | } // namespace ARDUINOJSON_NAMESPACE 35 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Document/DynamicJsonDocument.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // malloc, free 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | struct DefaultAllocator { 14 | void* allocate(size_t size) { 15 | return malloc(size); 16 | } 17 | 18 | void deallocate(void* ptr) { 19 | free(ptr); 20 | } 21 | 22 | void* reallocate(void* ptr, size_t new_size) { 23 | return realloc(ptr, new_size); 24 | } 25 | }; 26 | 27 | typedef BasicJsonDocument DynamicJsonDocument; 28 | 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Json/EscapeSequence.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | class EscapeSequence { 12 | public: 13 | // Optimized for code size on a 8-bit AVR 14 | static char escapeChar(char c) { 15 | const char *p = escapeTable(true); 16 | while (p[0] && p[1] != c) { 17 | p += 2; 18 | } 19 | return p[0]; 20 | } 21 | 22 | // Optimized for code size on a 8-bit AVR 23 | static char unescapeChar(char c) { 24 | const char *p = escapeTable(false); 25 | for (;;) { 26 | if (p[0] == '\0') 27 | return 0; 28 | if (p[0] == c) 29 | return p[1]; 30 | p += 2; 31 | } 32 | } 33 | 34 | private: 35 | static const char *escapeTable(bool excludeSolidus) { 36 | return &"//\"\"\\\\b\bf\fn\nr\rt\t"[excludeSolidus ? 2 : 0]; 37 | } 38 | }; 39 | } // namespace ARDUINOJSON_NAMESPACE 40 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Json/Latch.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | class Latch { 13 | public: 14 | Latch(TReader reader) : _reader(reader), _loaded(false) { 15 | #if ARDUINOJSON_DEBUG 16 | _ended = false; 17 | #endif 18 | } 19 | 20 | void clear() { 21 | _loaded = false; 22 | } 23 | 24 | int last() const { 25 | return _current; 26 | } 27 | 28 | FORCE_INLINE char current() { 29 | if (!_loaded) { 30 | load(); 31 | } 32 | return _current; 33 | } 34 | 35 | private: 36 | void load() { 37 | ARDUINOJSON_ASSERT(!_ended); 38 | int c = _reader.read(); 39 | #if ARDUINOJSON_DEBUG 40 | if (c <= 0) 41 | _ended = true; 42 | #endif 43 | _current = static_cast(c > 0 ? c : 0); 44 | _loaded = true; 45 | } 46 | 47 | TReader _reader; 48 | char _current; 49 | bool _loaded; 50 | #if ARDUINOJSON_DEBUG 51 | bool _ended; 52 | #endif 53 | }; 54 | 55 | } // namespace ARDUINOJSON_NAMESPACE 56 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Json/Utf8.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | namespace Utf8 { 12 | template 13 | inline void encodeCodepoint(uint32_t codepoint32, TStringBuilder& str) { 14 | // this function was optimize for code size on AVR 15 | 16 | // a buffer to store the string in reverse 17 | char buf[5]; 18 | char* p = buf; 19 | 20 | *(p++) = 0; 21 | if (codepoint32 < 0x80) { 22 | *(p++) = char((codepoint32)); 23 | } else { 24 | *(p++) = char((codepoint32 | 0x80) & 0xBF); 25 | uint16_t codepoint16 = uint16_t(codepoint32 >> 6); 26 | if (codepoint16 < 0x20) { // 0x800 27 | *(p++) = char(codepoint16 | 0xC0); 28 | } else { 29 | *(p++) = char((codepoint16 | 0x80) & 0xBF); 30 | codepoint16 = uint16_t(codepoint16 >> 6); 31 | if (codepoint16 < 0x10) { // 0x10000 32 | *(p++) = char(codepoint16 | 0xE0); 33 | } else { 34 | *(p++) = char((codepoint16 | 0x80) & 0xBF); 35 | codepoint16 = uint16_t(codepoint16 >> 6); 36 | *(p++) = char(codepoint16 | 0xF0); 37 | } 38 | } 39 | } 40 | 41 | while (*(--p)) { 42 | str.append(*p); 43 | } 44 | } 45 | } // namespace Utf8 46 | } // namespace ARDUINOJSON_NAMESPACE 47 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Memory/StringSlot.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include // for size_t 8 | 9 | #include 10 | 11 | #define JSON_STRING_SIZE(SIZE) (SIZE + 1) 12 | 13 | namespace ARDUINOJSON_NAMESPACE { 14 | 15 | struct StringSlot { 16 | char *value; 17 | size_t size; 18 | }; 19 | } // namespace ARDUINOJSON_NAMESPACE 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Misc/Visitable.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | struct Visitable { 12 | // template 13 | // void accept(Visitor&) const; 14 | }; 15 | 16 | template 17 | struct IsVisitable : is_base_of {}; 18 | 19 | template 20 | struct IsVisitable : IsVisitable {}; 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/MsgPack/endianess.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | #if ARDUINOJSON_LITTLE_ENDIAN 13 | inline void fixEndianess(uint8_t *p, integral_constant) { 14 | swap(p[0], p[7]); 15 | swap(p[1], p[6]); 16 | swap(p[2], p[5]); 17 | swap(p[3], p[4]); 18 | } 19 | 20 | inline void fixEndianess(uint8_t *p, integral_constant) { 21 | swap(p[0], p[3]); 22 | swap(p[1], p[2]); 23 | } 24 | 25 | inline void fixEndianess(uint8_t *p, integral_constant) { 26 | swap(p[0], p[1]); 27 | } 28 | 29 | inline void fixEndianess(uint8_t *, integral_constant) {} 30 | 31 | template 32 | inline void fixEndianess(T &value) { 33 | fixEndianess(reinterpret_cast(&value), 34 | integral_constant()); 35 | } 36 | #else 37 | template 38 | inline void fixEndianess(T &) {} 39 | #endif 40 | 41 | } // namespace ARDUINOJSON_NAMESPACE 42 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/MsgPack/ieee754.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | inline void doubleToFloat(const uint8_t d[8], uint8_t f[4]) { 12 | f[0] = uint8_t((d[0] & 0xC0) | (d[0] << 3 & 0x3f) | (d[1] >> 5)); 13 | f[1] = uint8_t((d[1] << 3) | (d[2] >> 5)); 14 | f[2] = uint8_t((d[2] << 3) | (d[3] >> 5)); 15 | f[3] = uint8_t((d[3] << 3) | (d[4] >> 5)); 16 | } 17 | 18 | } // namespace ARDUINOJSON_NAMESPACE 19 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Numbers/Float.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | #if ARDUINOJSON_USE_DOUBLE 13 | typedef double Float; 14 | #else 15 | typedef float Float; 16 | #endif 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Numbers/Integer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include // int64_t 11 | 12 | namespace ARDUINOJSON_NAMESPACE { 13 | 14 | #if ARDUINOJSON_USE_LONG_LONG 15 | typedef int64_t Integer; 16 | typedef uint64_t UInt; 17 | #else 18 | typedef long Integer; 19 | typedef unsigned long UInt; 20 | #endif 21 | 22 | } // namespace ARDUINOJSON_NAMESPACE 23 | 24 | #if ARDUINOJSON_HAS_LONG_LONG && !ARDUINOJSON_USE_LONG_LONG 25 | #define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) \ 26 | static_assert(sizeof(T) <= sizeof(ARDUINOJSON_NAMESPACE::Integer), \ 27 | "To use 64-bit integers with ArduinoJson, you must set " \ 28 | "ARDUINOJSON_USE_LONG_LONG to 1. See " \ 29 | "https://arduinojson.org/v6/api/config/use_long_long/"); 30 | #else 31 | #define ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(T) 32 | #endif 33 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Numbers/parseFloat.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | inline T parseFloat(const char* s) { 14 | // try to reuse the same parameters as JsonDeserializer 15 | typedef typename choose_largest::type TFloat; 16 | ParsedNumber value; 17 | parseNumber(s, value); 18 | return value.template as(); 19 | } 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Numbers/parseInteger.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | template 13 | T parseInteger(const char *s) { 14 | // try to reuse the same parameters as JsonDeserializer 15 | typedef typename choose_largest::type>::type 16 | TUInt; 17 | ParsedNumber value; 18 | parseNumber(s, value); 19 | return value.template as(); 20 | } 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Object/Pair.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | // A key value pair for CollectionData. 12 | class Pair { 13 | public: 14 | Pair(MemoryPool* pool, VariantSlot* slot) { 15 | if (slot) { 16 | _key = String(slot->key(), !slot->ownsKey()); 17 | _value = VariantRef(pool, slot->data()); 18 | } 19 | } 20 | 21 | String key() const { 22 | return _key; 23 | } 24 | 25 | VariantRef value() const { 26 | return _value; 27 | } 28 | 29 | private: 30 | String _key; 31 | VariantRef _value; 32 | }; 33 | 34 | class PairConst { 35 | public: 36 | PairConst(const VariantSlot* slot) { 37 | if (slot) { 38 | _key = String(slot->key(), !slot->ownsKey()); 39 | _value = VariantConstRef(slot->data()); 40 | } 41 | } 42 | 43 | String key() const { 44 | return _key; 45 | } 46 | 47 | VariantConstRef value() const { 48 | return _value; 49 | } 50 | 51 | private: 52 | String _key; 53 | VariantConstRef _value; 54 | }; 55 | } // namespace ARDUINOJSON_NAMESPACE 56 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/alias_cast.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include // for size_t 9 | 10 | #include 11 | #include "math.hpp" 12 | 13 | namespace ARDUINOJSON_NAMESPACE { 14 | 15 | template 16 | struct alias_cast_t { 17 | union { 18 | F raw; 19 | T data; 20 | }; 21 | }; 22 | 23 | template 24 | T alias_cast(F raw_data) { 25 | alias_cast_t ac; 26 | ac.raw = raw_data; 27 | return ac.data; 28 | } 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/assert.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #if ARDUINOJSON_DEBUG 10 | #include 11 | #define ARDUINOJSON_ASSERT(X) assert(X) 12 | #else 13 | #define ARDUINOJSON_ASSERT(X) ((void)0) 14 | #endif 15 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/attributes.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #ifdef _MSC_VER // Visual Studio 8 | 9 | #define FORCE_INLINE // __forceinline causes C4714 when returning std::string 10 | #define NO_INLINE __declspec(noinline) 11 | #define DEPRECATED(msg) __declspec(deprecated(msg)) 12 | 13 | #elif defined(__GNUC__) // GCC or Clang 14 | 15 | #define FORCE_INLINE __attribute__((always_inline)) 16 | #define NO_INLINE __attribute__((noinline)) 17 | #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5) 18 | #define DEPRECATED(msg) __attribute__((deprecated(msg))) 19 | #else 20 | #define DEPRECATED(msg) __attribute__((deprecated)) 21 | #endif 22 | 23 | #else // Other compilers 24 | 25 | #define FORCE_INLINE 26 | #define NO_INLINE 27 | #define DEPRECATED(msg) 28 | 29 | #endif 30 | 31 | #if __cplusplus >= 201103L 32 | #define NOEXCEPT noexcept 33 | #else 34 | #define NOEXCEPT throw() 35 | #endif 36 | 37 | #if defined(__has_attribute) 38 | #if __has_attribute(no_sanitize) 39 | #define ARDUINOJSON_NO_SANITIZE(check) __attribute__((no_sanitize(check))) 40 | #else 41 | #define ARDUINOJSON_NO_SANITIZE(check) 42 | #endif 43 | #else 44 | #define ARDUINOJSON_NO_SANITIZE(check) 45 | #endif 46 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/ctype.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | inline bool isdigit(char c) { 12 | return '0' <= c && c <= '9'; 13 | } 14 | 15 | inline bool issign(char c) { 16 | return '-' == c || c == '+'; 17 | } 18 | } // namespace ARDUINOJSON_NAMESPACE 19 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/gsl/not_null.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | template 13 | class not_null { 14 | public: 15 | explicit not_null(T ptr) : _ptr(ptr) { 16 | ARDUINOJSON_ASSERT(ptr != NULL); 17 | } 18 | 19 | T get() const { 20 | ARDUINOJSON_ASSERT(_ptr != NULL); 21 | return _ptr; 22 | } 23 | 24 | private: 25 | T _ptr; 26 | }; 27 | 28 | template 29 | not_null make_not_null(T ptr) { 30 | ARDUINOJSON_ASSERT(ptr != NULL); 31 | return not_null(ptr); 32 | } 33 | 34 | } // namespace ARDUINOJSON_NAMESPACE 35 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/limits.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits.hpp" 8 | 9 | #ifdef _MSC_VER 10 | #pragma warning(push) 11 | #pragma warning(disable : 4310) 12 | #endif 13 | 14 | namespace ARDUINOJSON_NAMESPACE { 15 | 16 | // Differs from standard because we can't use the symbols "min" and "max" 17 | template 18 | struct numeric_limits; 19 | 20 | template 21 | struct numeric_limits::value>::type> { 22 | static T lowest() { 23 | return 0; 24 | } 25 | static T highest() { 26 | return T(-1); 27 | } 28 | }; 29 | 30 | template 31 | struct numeric_limits< 32 | T, typename enable_if::value && is_signed::value>::type> { 33 | static T lowest() { 34 | return T(T(1) << (sizeof(T) * 8 - 1)); 35 | } 36 | static T highest() { 37 | return T(~lowest()); 38 | } 39 | }; 40 | 41 | } // namespace ARDUINOJSON_NAMESPACE 42 | 43 | #ifdef _MSC_VER 44 | #pragma warning(pop) 45 | #endif 46 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/math.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // Some libraries #define isnan() and isinf() so we need to check before 12 | // using this name 13 | 14 | #ifndef isnan 15 | template 16 | bool isnan(T x) { 17 | return x != x; 18 | } 19 | #endif 20 | 21 | #ifndef isinf 22 | template 23 | bool isinf(T x) { 24 | return x != 0.0 && x * 2 == x; 25 | } 26 | #endif 27 | } // namespace ARDUINOJSON_NAMESPACE 28 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/mpl/max.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // for size_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | // A meta-function that returns the highest value 14 | template Y)> 15 | struct Max {}; 16 | 17 | template 18 | struct Max { 19 | static const size_t value = X; 20 | }; 21 | 22 | template 23 | struct Max { 24 | static const size_t value = Y; 25 | }; 26 | } // namespace ARDUINOJSON_NAMESPACE 27 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/safe_strcmp.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // int8_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | inline int safe_strcmp(const char* a, const char* b) { 14 | if (a == b) 15 | return 0; 16 | if (!a) 17 | return -1; 18 | if (!b) 19 | return 1; 20 | return strcmp(a, b); 21 | } 22 | 23 | inline int safe_strncmp(const char* a, const char* b, size_t n) { 24 | if (a == b) 25 | return 0; 26 | if (!a) 27 | return -1; 28 | if (!b) 29 | return 1; 30 | return strncmp(a, b, n); 31 | } 32 | } // namespace ARDUINOJSON_NAMESPACE 33 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits/conditional.hpp" 8 | #include "type_traits/enable_if.hpp" 9 | #include "type_traits/integral_constant.hpp" 10 | #include "type_traits/is_array.hpp" 11 | #include "type_traits/is_base_of.hpp" 12 | #include "type_traits/is_class.hpp" 13 | #include "type_traits/is_const.hpp" 14 | #include "type_traits/is_convertible.hpp" 15 | #include "type_traits/is_enum.hpp" 16 | #include "type_traits/is_floating_point.hpp" 17 | #include "type_traits/is_integral.hpp" 18 | #include "type_traits/is_same.hpp" 19 | #include "type_traits/is_signed.hpp" 20 | #include "type_traits/is_unsigned.hpp" 21 | #include "type_traits/make_unsigned.hpp" 22 | #include "type_traits/remove_const.hpp" 23 | #include "type_traits/remove_reference.hpp" 24 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/conditional.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct conditional { 13 | typedef TrueType type; 14 | }; 15 | 16 | template 17 | struct conditional { 18 | typedef FalseType type; 19 | }; 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/declval.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | T declval(); 13 | 14 | } // namespace ARDUINOJSON_NAMESPACE 15 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/enable_if.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T if Condition is true. 12 | template 13 | struct enable_if {}; 14 | 15 | template 16 | struct enable_if { 17 | typedef T type; 18 | }; 19 | } // namespace ARDUINOJSON_NAMESPACE 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/integral_constant.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct integral_constant { 13 | static const T value = v; 14 | }; 15 | 16 | typedef integral_constant true_type; 17 | typedef integral_constant false_type; 18 | 19 | } // namespace ARDUINOJSON_NAMESPACE 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_array.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | #include // size_t 10 | 11 | namespace ARDUINOJSON_NAMESPACE { 12 | 13 | template 14 | struct is_array : false_type {}; 15 | 16 | template 17 | struct is_array : true_type {}; 18 | 19 | template 20 | struct is_array : true_type {}; 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_base_of.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that returns true if Derived inherits from TBase is an 12 | // integral type. 13 | template 14 | class is_base_of { 15 | protected: // <- to avoid GCC's "all member functions in class are private" 16 | typedef char Yes[1]; 17 | typedef char No[2]; 18 | 19 | static Yes &probe(const TBase *); 20 | static No &probe(...); 21 | 22 | public: 23 | static const bool value = 24 | sizeof(probe(reinterpret_cast(0))) == sizeof(Yes); 25 | }; 26 | } // namespace ARDUINOJSON_NAMESPACE 27 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_class.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "declval.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct is_class { 13 | protected: // <- to avoid GCC's "all member functions in class are private" 14 | typedef char Yes[1]; 15 | typedef char No[2]; 16 | 17 | template 18 | static Yes &probe(void (U::*)(void)); 19 | template 20 | static No &probe(...); 21 | 22 | public: 23 | static const bool value = sizeof(probe(0)) == sizeof(Yes); 24 | }; 25 | 26 | } // namespace ARDUINOJSON_NAMESPACE 27 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_const.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T without the const modifier 12 | template 13 | struct is_const : false_type {}; 14 | 15 | template 16 | struct is_const : true_type {}; 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_convertible.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "declval.hpp" 8 | 9 | #ifdef _MSC_VER 10 | #pragma warning(push) 11 | // conversion from 'T' to 'To', possible loss of data 12 | #pragma warning(disable : 4244) 13 | #endif 14 | 15 | #ifdef __ICCARM__ 16 | // Suppress IAR Compiler Warning[Pa093]: implicit conversion from floating point to integer 17 | #pragma diag_suppress=Pa093 18 | #endif 19 | 20 | namespace ARDUINOJSON_NAMESPACE { 21 | 22 | template 23 | struct is_convertible { 24 | protected: // <- to avoid GCC's "all member functions in class are private" 25 | typedef char Yes[1]; 26 | typedef char No[2]; 27 | 28 | static Yes &probe(To); 29 | static No &probe(...); 30 | 31 | public: 32 | static const bool value = sizeof(probe(declval())) == sizeof(Yes); 33 | }; 34 | 35 | } // namespace ARDUINOJSON_NAMESPACE 36 | 37 | #ifdef _MSC_VER 38 | #pragma warning(pop) 39 | #endif 40 | 41 | #ifdef __ICCARM__ 42 | #pragma diag_default=Pa093 43 | #endif 44 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_enum.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "is_class.hpp" 8 | #include "is_convertible.hpp" 9 | #include "is_floating_point.hpp" 10 | #include "is_integral.hpp" 11 | #include "is_same.hpp" 12 | 13 | namespace ARDUINOJSON_NAMESPACE { 14 | 15 | template 16 | struct is_enum { 17 | static const bool value = is_convertible::value && 18 | !is_class::value && !is_integral::value && 19 | !is_floating_point::value; 20 | }; 21 | 22 | } // namespace ARDUINOJSON_NAMESPACE 23 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_floating_point.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct is_floating_point : false_type {}; 13 | 14 | template <> 15 | struct is_floating_point : true_type {}; 16 | 17 | template <> 18 | struct is_floating_point : true_type {}; 19 | } // namespace ARDUINOJSON_NAMESPACE 20 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_integral.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include "is_same.hpp" 9 | 10 | namespace ARDUINOJSON_NAMESPACE { 11 | 12 | // A meta-function that returns true if T is an integral type. 13 | template 14 | struct is_integral { 15 | static const bool value = 16 | is_same::value || is_same::value || 17 | is_same::value || is_same::value || 18 | is_same::value || is_same::value || 19 | is_same::value || is_same::value || 20 | #if ARDUINOJSON_HAS_LONG_LONG 21 | is_same::value || 22 | is_same::value || 23 | #endif 24 | #if ARDUINOJSON_HAS_INT64 25 | is_same::value || 26 | is_same::value || 27 | #endif 28 | is_same::value || is_same::value; 29 | }; 30 | 31 | template 32 | struct is_integral : is_integral {}; 33 | } // namespace ARDUINOJSON_NAMESPACE 34 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_same.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that returns true if types T and U are the same. 12 | template 13 | struct is_same : false_type {}; 14 | 15 | template 16 | struct is_same : true_type {}; 17 | } // namespace ARDUINOJSON_NAMESPACE 18 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_signed.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | namespace ARDUINOJSON_NAMESPACE { 9 | 10 | template 11 | struct is_signed : false_type {}; 12 | 13 | template <> 14 | struct is_signed : true_type {}; 15 | 16 | template <> 17 | struct is_signed : true_type {}; 18 | 19 | template <> 20 | struct is_signed : true_type {}; 21 | 22 | template <> 23 | struct is_signed : true_type {}; 24 | 25 | template <> 26 | struct is_signed : true_type {}; 27 | 28 | template <> 29 | struct is_signed : true_type {}; 30 | 31 | template <> 32 | struct is_signed : true_type {}; 33 | 34 | #if ARDUINOJSON_HAS_LONG_LONG 35 | template <> 36 | struct is_signed : true_type {}; 37 | #endif 38 | 39 | #if ARDUINOJSON_HAS_INT64 40 | template <> 41 | struct is_signed : true_type {}; 42 | #endif 43 | } // namespace ARDUINOJSON_NAMESPACE 44 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/is_unsigned.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | namespace ARDUINOJSON_NAMESPACE { 9 | 10 | template 11 | struct is_unsigned : false_type {}; 12 | 13 | template <> 14 | struct is_unsigned : true_type {}; 15 | 16 | template <> 17 | struct is_unsigned : true_type {}; 18 | 19 | template <> 20 | struct is_unsigned : true_type {}; 21 | 22 | template <> 23 | struct is_unsigned : true_type {}; 24 | 25 | template <> 26 | struct is_unsigned : true_type {}; 27 | 28 | #if ARDUINOJSON_HAS_INT64 29 | template <> 30 | struct is_unsigned : true_type {}; 31 | #endif 32 | 33 | #if ARDUINOJSON_HAS_LONG_LONG 34 | template <> 35 | struct is_unsigned : true_type {}; 36 | #endif 37 | } // namespace ARDUINOJSON_NAMESPACE 38 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_const.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T without the const modifier 12 | template 13 | struct remove_const { 14 | typedef T type; 15 | }; 16 | template 17 | struct remove_const { 18 | typedef T type; 19 | }; 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/remove_reference.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A meta-function that return the type T without the reference modifier. 12 | template 13 | struct remove_reference { 14 | typedef T type; 15 | }; 16 | template 17 | struct remove_reference { 18 | typedef T type; 19 | }; 20 | } // namespace ARDUINOJSON_NAMESPACE 21 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/type_traits/type_identity.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "integral_constant.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | struct type_identity { 13 | typedef T type; 14 | }; 15 | } // namespace ARDUINOJSON_NAMESPACE 16 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Polyfills/utility.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include "type_traits.hpp" 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | template 11 | inline void swap(T& a, T& b) { 12 | T t(a); 13 | a = b; 14 | b = t; 15 | } 16 | 17 | #if ARDUINOJSON_HAS_RVALUE_REFERENCES 18 | template 19 | typename remove_reference::type&& move(T&& t) { 20 | return static_cast::type&&>(t); 21 | } 22 | #else 23 | template 24 | T& move(T& t) { 25 | return t; 26 | } 27 | #endif 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writer.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // The default writer is a simple wrapper for Writers that are not copiable 12 | template 13 | class Writer { 14 | public: 15 | explicit Writer(TDestination& dest) : _dest(&dest) {} 16 | 17 | size_t write(uint8_t c) { 18 | return _dest->write(c); 19 | } 20 | 21 | size_t write(const uint8_t* s, size_t n) { 22 | return _dest->write(s, n); 23 | } 24 | 25 | private: 26 | TDestination* _dest; 27 | }; 28 | 29 | } // namespace ARDUINOJSON_NAMESPACE 30 | 31 | #include 32 | 33 | #if ARDUINOJSON_ENABLE_STD_STRING 34 | #include 35 | #endif 36 | 37 | #if ARDUINOJSON_ENABLE_ARDUINO_STRING 38 | #include 39 | #endif 40 | 41 | #if ARDUINOJSON_ENABLE_STD_STREAM 42 | #include 43 | #endif 44 | 45 | #if ARDUINOJSON_ENABLE_ARDUINO_PRINT 46 | #include 47 | #endif 48 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writers/ArduinoStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template <> 12 | class Writer< ::String, void> { 13 | static const size_t bufferCapacity = ARDUINOJSON_STRING_BUFFER_SIZE; 14 | 15 | public: 16 | explicit Writer(::String &str) : _destination(&str) { 17 | _size = 0; 18 | } 19 | 20 | ~Writer() { 21 | flush(); 22 | } 23 | 24 | size_t write(uint8_t c) { 25 | ARDUINOJSON_ASSERT(_size < bufferCapacity); 26 | _buffer[_size++] = static_cast(c); 27 | if (_size + 1 >= bufferCapacity) 28 | flush(); 29 | return 1; 30 | } 31 | 32 | size_t write(const uint8_t *s, size_t n) { 33 | for (size_t i = 0; i < n; i++) { 34 | write(s[i]); 35 | } 36 | return n; 37 | } 38 | 39 | private: 40 | void flush() { 41 | ARDUINOJSON_ASSERT(_size < bufferCapacity); 42 | _buffer[_size] = 0; 43 | *_destination += _buffer; 44 | _size = 0; 45 | } 46 | 47 | ::String *_destination; 48 | char _buffer[bufferCapacity]; 49 | size_t _size; 50 | }; 51 | 52 | } // namespace ARDUINOJSON_NAMESPACE 53 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writers/DummyWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | class DummyWriter { 12 | public: 13 | size_t write(uint8_t) { 14 | return 1; 15 | } 16 | 17 | size_t write(const uint8_t*, size_t n) { 18 | return n; 19 | } 20 | }; 21 | } // namespace ARDUINOJSON_NAMESPACE 22 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writers/PrintWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | namespace ARDUINOJSON_NAMESPACE { 8 | 9 | template 10 | class Writer< 11 | TDestination, 12 | typename enable_if::value>::type> { 13 | public: 14 | explicit Writer(::Print& print) : _print(&print) {} 15 | 16 | size_t write(uint8_t c) { 17 | return _print->write(c); 18 | } 19 | 20 | size_t write(const uint8_t* s, size_t n) { 21 | return _print->write(s, n); 22 | } 23 | 24 | private: 25 | ::Print* _print; 26 | }; 27 | 28 | } // namespace ARDUINOJSON_NAMESPACE 29 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writers/StaticStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | // A Print implementation that allows to write in a char[] 12 | class StaticStringWriter { 13 | public: 14 | StaticStringWriter(char *buf, size_t size) : end(buf + size - 1), p(buf) { 15 | *p = '\0'; 16 | } 17 | 18 | size_t write(uint8_t c) { 19 | if (p >= end) 20 | return 0; 21 | *p++ = static_cast(c); 22 | *p = '\0'; 23 | return 1; 24 | } 25 | 26 | size_t write(const uint8_t *s, size_t n) { 27 | char *begin = p; 28 | while (p < end && n > 0) { 29 | *p++ = static_cast(*s++); 30 | n--; 31 | } 32 | *p = '\0'; 33 | return size_t(p - begin); 34 | } 35 | 36 | private: 37 | char *end; 38 | char *p; 39 | }; 40 | } // namespace ARDUINOJSON_NAMESPACE 41 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStreamWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template 12 | class Writer< 13 | TDestination, 14 | typename enable_if::value>::type> { 15 | public: 16 | explicit Writer(std::ostream& os) : _os(&os) {} 17 | 18 | size_t write(uint8_t c) { 19 | _os->put(static_cast(c)); 20 | return 1; 21 | } 22 | 23 | size_t write(const uint8_t* s, size_t n) { 24 | _os->write(reinterpret_cast(s), 25 | static_cast(n)); 26 | return n; 27 | } 28 | 29 | private: 30 | std::ostream* _os; 31 | }; 32 | } // namespace ARDUINOJSON_NAMESPACE 33 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/Writers/StdStringWriter.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | #include 9 | 10 | #include 11 | 12 | namespace ARDUINOJSON_NAMESPACE { 13 | 14 | template 15 | struct is_std_string : false_type {}; 16 | 17 | template 18 | struct is_std_string > 19 | : true_type {}; 20 | 21 | template 22 | class Writer::value>::type> { 24 | public: 25 | Writer(TDestination &str) : _str(&str) {} 26 | 27 | size_t write(uint8_t c) { 28 | _str->operator+=(static_cast(c)); 29 | return 1; 30 | } 31 | 32 | size_t write(const uint8_t *s, size_t n) { 33 | _str->append(reinterpret_cast(s), n); 34 | return n; 35 | } 36 | 37 | private: 38 | TDestination *_str; 39 | }; 40 | } // namespace ARDUINOJSON_NAMESPACE 41 | -------------------------------------------------------------------------------- /arduino/libraries/ArduinoJson/src/ArduinoJson/Serialization/measure.hpp: -------------------------------------------------------------------------------- 1 | // ArduinoJson - arduinojson.org 2 | // Copyright Benoit Blanchon 2014-2020 3 | // MIT License 4 | 5 | #pragma once 6 | 7 | #include 8 | 9 | namespace ARDUINOJSON_NAMESPACE { 10 | 11 | template