From ce8be4b5836d1d62987d0be4f1aee0fa22212694 Mon Sep 17 00:00:00 2001 From: Alexander Kalankhodzhaev Date: Tue, 2 Nov 2021 23:28:59 +0300 Subject: [PATCH] Adds tagged union (rust enum) support for scale codec implementation --- readme.md | 1 - .../src/test/resources/Annotated.java | 19 ++ .../substrateclient/scale/ScaleType.java | 35 ++- .../scale/readers/union/BaseUnionReader.java | 42 +++ .../scale/readers/union/Union10Reader.java | 19 ++ .../scale/readers/union/Union11Reader.java | 20 ++ .../scale/readers/union/Union12Reader.java | 21 ++ .../scale/readers/union/Union1Reader.java | 9 + .../scale/readers/union/Union2Reader.java | 9 + .../scale/readers/union/Union3Reader.java | 12 + .../scale/readers/union/Union4Reader.java | 13 + .../scale/readers/union/Union5Reader.java | 14 + .../scale/readers/union/Union6Reader.java | 15 + .../scale/readers/union/Union7Reader.java | 16 + .../scale/readers/union/Union8Reader.java | 17 + .../scale/readers/union/Union9Reader.java | 18 ++ .../scale/registries/ScaleReaderRegistry.java | 14 + .../scale/registries/ScaleWriterRegistry.java | 14 + .../scale/writers/union/BaseUnionWriter.java | 36 +++ .../scale/writers/union/Union10Writer.java | 19 ++ .../scale/writers/union/Union11Writer.java | 20 ++ .../scale/writers/union/Union12Writer.java | 21 ++ .../scale/writers/union/Union1Writer.java | 9 + .../scale/writers/union/Union2Writer.java | 9 + .../scale/writers/union/Union3Writer.java | 12 + .../scale/writers/union/Union4Writer.java | 13 + .../scale/writers/union/Union5Writer.java | 14 + .../scale/writers/union/Union6Writer.java | 15 + .../scale/writers/union/Union7Writer.java | 16 + .../scale/writers/union/Union8Writer.java | 17 + .../scale/writers/union/Union9Writer.java | 18 ++ .../readers/union/Union10ReaderTest.java | 28 ++ .../readers/union/Union11ReaderTest.java | 29 ++ .../readers/union/Union12ReaderTest.java | 30 ++ .../scale/readers/union/Union1ReaderTest.java | 24 ++ .../scale/readers/union/Union2ReaderTest.java | 35 +++ .../scale/readers/union/Union3ReaderTest.java | 44 +++ .../scale/readers/union/Union4ReaderTest.java | 22 ++ .../scale/readers/union/Union5ReaderTest.java | 23 ++ .../scale/readers/union/Union6ReaderTest.java | 24 ++ .../scale/readers/union/Union7ReaderTest.java | 25 ++ .../scale/readers/union/Union8ReaderTest.java | 26 ++ .../scale/readers/union/Union9ReaderTest.java | 27 ++ .../readers/union/UnionReaderTester.java | 33 ++ .../writers/union/Union10WriterTest.java | 26 ++ .../writers/union/Union11WriterTest.java | 27 ++ .../writers/union/Union12WriterTest.java | 28 ++ .../scale/writers/union/Union1WriterTest.java | 24 ++ .../scale/writers/union/Union2WriterTest.java | 34 ++ .../scale/writers/union/Union3WriterTest.java | 19 ++ .../scale/writers/union/Union4WriterTest.java | 20 ++ .../scale/writers/union/Union5WriterTest.java | 21 ++ .../scale/writers/union/Union6WriterTest.java | 22 ++ .../scale/writers/union/Union7WriterTest.java | 23 ++ .../scale/writers/union/Union8WriterTest.java | 24 ++ .../scale/writers/union/Union9WriterTest.java | 25 ++ .../writers/union/UnionWriterTester.java | 33 ++ .../substrateclient/types/union/Union.java | 10 + .../substrateclient/types/union/Union1.java | 27 ++ .../substrateclient/types/union/Union10.java | 176 +++++++++++ .../substrateclient/types/union/Union11.java | 192 ++++++++++++ .../substrateclient/types/union/Union12.java | 208 +++++++++++++ .../substrateclient/types/union/Union2.java | 42 +++ .../substrateclient/types/union/Union3.java | 64 ++++ .../substrateclient/types/union/Union4.java | 80 +++++ .../substrateclient/types/union/Union5.java | 96 ++++++ .../substrateclient/types/union/Union6.java | 112 +++++++ .../substrateclient/types/union/Union7.java | 128 ++++++++ .../substrateclient/types/union/Union8.java | 144 +++++++++ .../substrateclient/types/union/Union9.java | 160 ++++++++++ .../types/union/Union10Test.java | 227 ++++++++++++++ .../types/union/Union11Test.java | 258 ++++++++++++++++ .../types/union/Union12Test.java | 291 ++++++++++++++++++ .../types/union/Union1Test.java | 28 ++ .../types/union/Union2Test.java | 44 +++ .../types/union/Union3Test.java | 66 ++++ .../types/union/Union4Test.java | 83 +++++ .../types/union/Union5Test.java | 102 ++++++ .../types/union/Union6Test.java | 123 ++++++++ .../types/union/Union7Test.java | 146 +++++++++ .../types/union/Union8Test.java | 171 ++++++++++ .../types/union/Union9Test.java | 198 ++++++++++++ 82 files changed, 4397 insertions(+), 2 deletions(-) create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/BaseUnionReader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union10Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union11Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union12Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union1Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union2Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union3Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union4Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union5Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union6Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union7Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union8Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union9Reader.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/BaseUnionWriter.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union10Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union11Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union12Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union1Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union2Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union3Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union4Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union5Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union6Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union7Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union8Writer.java create mode 100644 scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union9Writer.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union10ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union11ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union12ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union1ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union2ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union3ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union4ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union5ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union6ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union7ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union8ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union9ReaderTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/UnionReaderTester.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union10WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union11WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union12WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union1WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union2WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union3WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union4WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union5WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union6WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union7WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union8WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union9WriterTest.java create mode 100644 scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/UnionWriterTester.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union1.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union10.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union11.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union12.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union2.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union3.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union4.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union5.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union6.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union7.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union8.java create mode 100644 types/src/main/java/com/strategyobject/substrateclient/types/union/Union9.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union10Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union11Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union12Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union1Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union2Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union3Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union4Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union5Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union6Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union7Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union8Test.java create mode 100644 types/src/test/java/com/strategyobject/substrateclient/types/union/Union9Test.java diff --git a/readme.md b/readme.md index aa022e64..6e5b87f0 100644 --- a/readme.md +++ b/readme.md @@ -150,7 +150,6 @@ api.pallete(MyPallet.class) - [x] Transport - layer that interacts with a node. It provides async API for RPC requests. - [ ] Scale - [x] Scale codec - implementation of the [SCALE](https://docs.substrate.io/v3/advanced/scale-codec/) for standard types. - - [ ] Support scale for *union* types - [x] Scale code generation - approach to generate scale encoders/decoders for annotated classes. - [ ] Signing: - [x] SR25519 diff --git a/scale/scale-codegen/src/test/resources/Annotated.java b/scale/scale-codegen/src/test/resources/Annotated.java index 05064b53..4231671c 100644 --- a/scale/scale-codegen/src/test/resources/Annotated.java +++ b/scale/scale-codegen/src/test/resources/Annotated.java @@ -78,6 +78,17 @@ public class Annotated { @Scale(U128.class) private BigInteger testU128; + @ScaleGeneric( + template = "Union", + types = { + @Scale(value = Union3.class, name = "Union"), + @Scale(I32.class), + @Scale(Bool.class), + @Scale(ScaleType.String.class) + } + ) + private com.strategyobject.substrateclient.types.union.Union3 testUnion; + @ScaleGeneric( template = "Vec", types = { @@ -235,6 +246,14 @@ public void setTestU128(BigInteger testU128) { this.testU128 = testU128; } + public com.strategyobject.substrateclient.types.union.Union3 getTestUnion() { + return testUnion; + } + + public void setTestUnion(com.strategyobject.substrateclient.types.union.Union3 testUnion) { + this.testUnion = testUnion; + } + public List getTestVec() { return testVec; } diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/ScaleType.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/ScaleType.java index 9630f373..22ab5174 100644 --- a/scale/src/main/java/com/strategyobject/substrateclient/scale/ScaleType.java +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/ScaleType.java @@ -55,6 +55,39 @@ class U128 implements ScaleType { class Vec implements ScaleType { } - class Union implements ScaleType { + class Union1 implements ScaleType { + } + + class Union2 implements ScaleType { + } + + class Union3 implements ScaleType { + } + + class Union4 implements ScaleType { + } + + class Union5 implements ScaleType { + } + + class Union6 implements ScaleType { + } + + class Union7 implements ScaleType { + } + + class Union8 implements ScaleType { + } + + class Union9 implements ScaleType { + } + + class Union10 implements ScaleType { + } + + class Union11 implements ScaleType { + } + + class Union12 implements ScaleType { } } diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/BaseUnionReader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/BaseUnionReader.java new file mode 100644 index 00000000..8a6ea7ff --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/BaseUnionReader.java @@ -0,0 +1,42 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.google.common.base.Preconditions; +import com.strategyobject.substrateclient.common.io.Streamer; +import com.strategyobject.substrateclient.scale.ScaleReader; +import com.strategyobject.substrateclient.types.union.Union; +import lombok.NonNull; +import lombok.val; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Arrays; +import java.util.NoSuchElementException; +import java.util.function.Function; + +public abstract class BaseUnionReader implements ScaleReader { + private final int unionSize; + @SuppressWarnings("rawtypes") + private final Function[] createUnion; + + @SafeVarargs + protected BaseUnionReader(int unionSize, Function... createUnion) { + Preconditions.checkArgument(createUnion.length == unionSize); + + this.unionSize = unionSize; + this.createUnion = createUnion; + } + + @SuppressWarnings("unchecked") + @Override + public T read(@NonNull InputStream stream, ScaleReader... readers) throws IOException { + Preconditions.checkArgument(readers.length == unionSize); + Arrays.stream(readers).forEach(Preconditions::checkNotNull); + + val index = Streamer.readByte(stream); + if (index >= unionSize) { + throw new NoSuchElementException("Union index is out of bound."); + } + + return (T) createUnion[index].apply(readers[index].read(stream)); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union10Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union10Reader.java new file mode 100644 index 00000000..38a0f840 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union10Reader.java @@ -0,0 +1,19 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union10; + +public class Union10Reader extends BaseUnionReader> { + public Union10Reader() { + super(10, + Union10::withItem0, + Union10::withItem1, + Union10::withItem2, + Union10::withItem3, + Union10::withItem4, + Union10::withItem5, + Union10::withItem6, + Union10::withItem7, + Union10::withItem8, + Union10::withItem9); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union11Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union11Reader.java new file mode 100644 index 00000000..8f4743b7 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union11Reader.java @@ -0,0 +1,20 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union11; + +public class Union11Reader extends BaseUnionReader> { + public Union11Reader() { + super(11, + Union11::withItem0, + Union11::withItem1, + Union11::withItem2, + Union11::withItem3, + Union11::withItem4, + Union11::withItem5, + Union11::withItem6, + Union11::withItem7, + Union11::withItem8, + Union11::withItem9, + Union11::withItem10); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union12Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union12Reader.java new file mode 100644 index 00000000..0e98403a --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union12Reader.java @@ -0,0 +1,21 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union12; + +public class Union12Reader extends BaseUnionReader> { + public Union12Reader() { + super(12, + Union12::withItem0, + Union12::withItem1, + Union12::withItem2, + Union12::withItem3, + Union12::withItem4, + Union12::withItem5, + Union12::withItem6, + Union12::withItem7, + Union12::withItem8, + Union12::withItem9, + Union12::withItem10, + Union12::withItem11); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union1Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union1Reader.java new file mode 100644 index 00000000..10fbbb79 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union1Reader.java @@ -0,0 +1,9 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union1; + +public class Union1Reader extends BaseUnionReader> { + public Union1Reader() { + super(1, Union1::withItem0); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union2Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union2Reader.java new file mode 100644 index 00000000..ef2a99ad --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union2Reader.java @@ -0,0 +1,9 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union2; + +public class Union2Reader extends BaseUnionReader> { + public Union2Reader() { + super(2, Union2::withItem0, Union2::withItem1); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union3Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union3Reader.java new file mode 100644 index 00000000..3719caa0 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union3Reader.java @@ -0,0 +1,12 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union3; + +public class Union3Reader extends BaseUnionReader> { + public Union3Reader() { + super(3, + Union3::withItem0, + Union3::withItem1, + Union3::withItem2); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union4Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union4Reader.java new file mode 100644 index 00000000..46d95f18 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union4Reader.java @@ -0,0 +1,13 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union4; + +public class Union4Reader extends BaseUnionReader> { + public Union4Reader() { + super(4, + Union4::withItem0, + Union4::withItem1, + Union4::withItem2, + Union4::withItem3); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union5Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union5Reader.java new file mode 100644 index 00000000..b4a6134d --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union5Reader.java @@ -0,0 +1,14 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union5; + +public class Union5Reader extends BaseUnionReader> { + public Union5Reader() { + super(5, + Union5::withItem0, + Union5::withItem1, + Union5::withItem2, + Union5::withItem3, + Union5::withItem4); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union6Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union6Reader.java new file mode 100644 index 00000000..49399975 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union6Reader.java @@ -0,0 +1,15 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union6; + +public class Union6Reader extends BaseUnionReader> { + public Union6Reader() { + super(6, + Union6::withItem0, + Union6::withItem1, + Union6::withItem2, + Union6::withItem3, + Union6::withItem4, + Union6::withItem5); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union7Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union7Reader.java new file mode 100644 index 00000000..1bcaebe6 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union7Reader.java @@ -0,0 +1,16 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union7; + +public class Union7Reader extends BaseUnionReader> { + public Union7Reader() { + super(7, + Union7::withItem0, + Union7::withItem1, + Union7::withItem2, + Union7::withItem3, + Union7::withItem4, + Union7::withItem5, + Union7::withItem6); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union8Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union8Reader.java new file mode 100644 index 00000000..2e77b33b --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union8Reader.java @@ -0,0 +1,17 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union8; + +public class Union8Reader extends BaseUnionReader> { + public Union8Reader() { + super(8, + Union8::withItem0, + Union8::withItem1, + Union8::withItem2, + Union8::withItem3, + Union8::withItem4, + Union8::withItem5, + Union8::withItem6, + Union8::withItem7); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union9Reader.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union9Reader.java new file mode 100644 index 00000000..dcec4eaa --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/readers/union/Union9Reader.java @@ -0,0 +1,18 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union9; + +public class Union9Reader extends BaseUnionReader> { + public Union9Reader() { + super(9, + Union9::withItem0, + Union9::withItem1, + Union9::withItem2, + Union9::withItem3, + Union9::withItem4, + Union9::withItem5, + Union9::withItem6, + Union9::withItem7, + Union9::withItem8); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleReaderRegistry.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleReaderRegistry.java index aa36c7e5..ea7477eb 100644 --- a/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleReaderRegistry.java +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleReaderRegistry.java @@ -5,7 +5,9 @@ import com.strategyobject.substrateclient.scale.ScaleType; import com.strategyobject.substrateclient.scale.annotations.AutoRegister; import com.strategyobject.substrateclient.scale.readers.*; +import com.strategyobject.substrateclient.scale.readers.union.*; import com.strategyobject.substrateclient.types.Result; +import com.strategyobject.substrateclient.types.union.*; import lombok.NonNull; import lombok.val; import org.slf4j.Logger; @@ -43,6 +45,18 @@ private ScaleReaderRegistry() { register(new U32Reader(), ScaleType.U32.class); register(new U64Reader(), ScaleType.U64.class); register(new U128Reader(), ScaleType.U128.class); + register(new Union1Reader(), Union1.class, ScaleType.Union1.class); + register(new Union2Reader(), Union2.class, ScaleType.Union2.class); + register(new Union3Reader(), Union3.class, ScaleType.Union3.class); + register(new Union4Reader(), Union4.class, ScaleType.Union4.class); + register(new Union5Reader(), Union5.class, ScaleType.Union5.class); + register(new Union6Reader(), Union6.class, ScaleType.Union6.class); + register(new Union7Reader(), Union7.class, ScaleType.Union7.class); + register(new Union8Reader(), Union8.class, ScaleType.Union8.class); + register(new Union9Reader(), Union9.class, ScaleType.Union9.class); + register(new Union10Reader(), Union10.class, ScaleType.Union10.class); + register(new Union11Reader(), Union11.class, ScaleType.Union11.class); + register(new Union12Reader(), Union12.class, ScaleType.Union12.class); register(new VecReader(), ScaleType.Vec.class, List.class); register(new VoidReader(), Void.class); diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleWriterRegistry.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleWriterRegistry.java index f3ee57e7..0a564f05 100644 --- a/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleWriterRegistry.java +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/registries/ScaleWriterRegistry.java @@ -6,9 +6,11 @@ import com.strategyobject.substrateclient.scale.ScaleWriter; import com.strategyobject.substrateclient.scale.annotations.AutoRegister; import com.strategyobject.substrateclient.scale.writers.*; +import com.strategyobject.substrateclient.scale.writers.union.*; import com.strategyobject.substrateclient.types.PublicKey; import com.strategyobject.substrateclient.types.Result; import com.strategyobject.substrateclient.types.SignatureData; +import com.strategyobject.substrateclient.types.union.*; import lombok.NonNull; import lombok.val; import org.slf4j.Logger; @@ -46,6 +48,18 @@ private ScaleWriterRegistry() { register(new U32Writer(), ScaleType.U32.class); register(new U64Writer(), ScaleType.U64.class); register(new U128Writer(), ScaleType.U128.class); + register(new Union1Writer(), Union1.class, ScaleType.Union1.class); + register(new Union2Writer(), Union2.class, ScaleType.Union2.class); + register(new Union3Writer(), Union3.class, ScaleType.Union3.class); + register(new Union4Writer(), Union4.class, ScaleType.Union4.class); + register(new Union5Writer(), Union5.class, ScaleType.Union5.class); + register(new Union6Writer(), Union6.class, ScaleType.Union6.class); + register(new Union7Writer(), Union7.class, ScaleType.Union7.class); + register(new Union8Writer(), Union8.class, ScaleType.Union8.class); + register(new Union9Writer(), Union9.class, ScaleType.Union9.class); + register(new Union10Writer(), Union10.class, ScaleType.Union10.class); + register(new Union11Writer(), Union11.class, ScaleType.Union11.class); + register(new Union12Writer(), Union12.class, ScaleType.Union12.class); register(new VecWriter(), ScaleType.Vec.class, List.class); register(new VoidWriter(), Void.class); register(new SelfWriter(), ScaleSelfWritable.class); diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/BaseUnionWriter.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/BaseUnionWriter.java new file mode 100644 index 00000000..c1bb103a --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/BaseUnionWriter.java @@ -0,0 +1,36 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.google.common.base.Preconditions; +import com.strategyobject.substrateclient.scale.ScaleWriter; +import com.strategyobject.substrateclient.types.union.Union; +import lombok.NonNull; +import lombok.val; + +import java.io.IOException; +import java.io.OutputStream; +import java.util.Arrays; +import java.util.function.Function; + +public abstract class BaseUnionWriter implements ScaleWriter { + private final int unionSize; + private final Function[] getItem; + + @SafeVarargs + protected BaseUnionWriter(int unionSize, Function... getItem) { + Preconditions.checkArgument(getItem.length == unionSize); + + this.unionSize = unionSize; + this.getItem = getItem; + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Override + public void write(@NonNull T value, @NonNull OutputStream stream, ScaleWriter... writers) throws IOException { + Preconditions.checkArgument(writers.length == unionSize); + Arrays.stream(writers).forEach(Preconditions::checkNotNull); + + val index = value.getIndex(); + stream.write(index); + ((ScaleWriter) writers[index]).write(getItem[index].apply(value), stream); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union10Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union10Writer.java new file mode 100644 index 00000000..03999963 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union10Writer.java @@ -0,0 +1,19 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union10; + +public class Union10Writer extends BaseUnionWriter> { + public Union10Writer() { + super(10, + Union10::getItem0, + Union10::getItem1, + Union10::getItem2, + Union10::getItem3, + Union10::getItem4, + Union10::getItem5, + Union10::getItem6, + Union10::getItem7, + Union10::getItem8, + Union10::getItem9); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union11Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union11Writer.java new file mode 100644 index 00000000..4c11fe7d --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union11Writer.java @@ -0,0 +1,20 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union11; + +public class Union11Writer extends BaseUnionWriter> { + public Union11Writer() { + super(11, + Union11::getItem0, + Union11::getItem1, + Union11::getItem2, + Union11::getItem3, + Union11::getItem4, + Union11::getItem5, + Union11::getItem6, + Union11::getItem7, + Union11::getItem8, + Union11::getItem9, + Union11::getItem10); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union12Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union12Writer.java new file mode 100644 index 00000000..927cf8af --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union12Writer.java @@ -0,0 +1,21 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union12; + +public class Union12Writer extends BaseUnionWriter> { + public Union12Writer() { + super(12, + Union12::getItem0, + Union12::getItem1, + Union12::getItem2, + Union12::getItem3, + Union12::getItem4, + Union12::getItem5, + Union12::getItem6, + Union12::getItem7, + Union12::getItem8, + Union12::getItem9, + Union12::getItem10, + Union12::getItem11); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union1Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union1Writer.java new file mode 100644 index 00000000..51851fe3 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union1Writer.java @@ -0,0 +1,9 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union1; + +public class Union1Writer extends BaseUnionWriter> { + public Union1Writer() { + super(1, Union1::getItem0); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union2Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union2Writer.java new file mode 100644 index 00000000..e13c6e18 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union2Writer.java @@ -0,0 +1,9 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union2; + +public class Union2Writer extends BaseUnionWriter> { + public Union2Writer() { + super(2, Union2::getItem0, Union2::getItem1); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union3Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union3Writer.java new file mode 100644 index 00000000..5c3122ee --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union3Writer.java @@ -0,0 +1,12 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union3; + +public class Union3Writer extends BaseUnionWriter> { + public Union3Writer() { + super(3, + Union3::getItem0, + Union3::getItem1, + Union3::getItem2); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union4Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union4Writer.java new file mode 100644 index 00000000..49aefbe8 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union4Writer.java @@ -0,0 +1,13 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union4; + +public class Union4Writer extends BaseUnionWriter> { + public Union4Writer() { + super(4, + Union4::getItem0, + Union4::getItem1, + Union4::getItem2, + Union4::getItem3); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union5Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union5Writer.java new file mode 100644 index 00000000..eb35270e --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union5Writer.java @@ -0,0 +1,14 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union5; + +public class Union5Writer extends BaseUnionWriter> { + public Union5Writer() { + super(5, + Union5::getItem0, + Union5::getItem1, + Union5::getItem2, + Union5::getItem3, + Union5::getItem4); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union6Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union6Writer.java new file mode 100644 index 00000000..d3433f53 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union6Writer.java @@ -0,0 +1,15 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union6; + +public class Union6Writer extends BaseUnionWriter> { + public Union6Writer() { + super(6, + Union6::getItem0, + Union6::getItem1, + Union6::getItem2, + Union6::getItem3, + Union6::getItem4, + Union6::getItem5); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union7Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union7Writer.java new file mode 100644 index 00000000..7d35ee2c --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union7Writer.java @@ -0,0 +1,16 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union7; + +public class Union7Writer extends BaseUnionWriter> { + public Union7Writer() { + super(7, + Union7::getItem0, + Union7::getItem1, + Union7::getItem2, + Union7::getItem3, + Union7::getItem4, + Union7::getItem5, + Union7::getItem6); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union8Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union8Writer.java new file mode 100644 index 00000000..9fe80aa4 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union8Writer.java @@ -0,0 +1,17 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union8; + +public class Union8Writer extends BaseUnionWriter> { + public Union8Writer() { + super(8, + Union8::getItem0, + Union8::getItem1, + Union8::getItem2, + Union8::getItem3, + Union8::getItem4, + Union8::getItem5, + Union8::getItem6, + Union8::getItem7); + } +} diff --git a/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union9Writer.java b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union9Writer.java new file mode 100644 index 00000000..4ed4edf3 --- /dev/null +++ b/scale/src/main/java/com/strategyobject/substrateclient/scale/writers/union/Union9Writer.java @@ -0,0 +1,18 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union9; + +public class Union9Writer extends BaseUnionWriter> { + public Union9Writer() { + super(9, + Union9::getItem0, + Union9::getItem1, + Union9::getItem2, + Union9::getItem3, + Union9::getItem4, + Union9::getItem5, + Union9::getItem6, + Union9::getItem7, + Union9::getItem8); + } +} diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union10ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union10ReaderTest.java new file mode 100644 index 00000000..7b9c5c37 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union10ReaderTest.java @@ -0,0 +1,28 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union10; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union10ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union10Reader(), new Function[]{ + x -> ((Union10) x).getItem0(), + x -> ((Union10) x).getItem1(), + x -> ((Union10) x).getItem2(), + x -> ((Union10) x).getItem3(), + x -> ((Union10) x).getItem4(), + x -> ((Union10) x).getItem5(), + x -> ((Union10) x).getItem6(), + x -> ((Union10) x).getItem7(), + x -> ((Union10) x).getItem8(), + x -> ((Union10) x).getItem9() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union11ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union11ReaderTest.java new file mode 100644 index 00000000..1a99d522 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union11ReaderTest.java @@ -0,0 +1,29 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union11; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union11ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union11Reader(), new Function[]{ + x -> ((Union11) x).getItem0(), + x -> ((Union11) x).getItem1(), + x -> ((Union11) x).getItem2(), + x -> ((Union11) x).getItem3(), + x -> ((Union11) x).getItem4(), + x -> ((Union11) x).getItem5(), + x -> ((Union11) x).getItem6(), + x -> ((Union11) x).getItem7(), + x -> ((Union11) x).getItem8(), + x -> ((Union11) x).getItem9(), + x -> ((Union11) x).getItem10() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union12ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union12ReaderTest.java new file mode 100644 index 00000000..80167ef4 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union12ReaderTest.java @@ -0,0 +1,30 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union12; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union12ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union12Reader(), new Function[]{ + x -> ((Union12) x).getItem0(), + x -> ((Union12) x).getItem1(), + x -> ((Union12) x).getItem2(), + x -> ((Union12) x).getItem3(), + x -> ((Union12) x).getItem4(), + x -> ((Union12) x).getItem5(), + x -> ((Union12) x).getItem6(), + x -> ((Union12) x).getItem7(), + x -> ((Union12) x).getItem8(), + x -> ((Union12) x).getItem9(), + x -> ((Union12) x).getItem10(), + x -> ((Union12) x).getItem11() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union1ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union1ReaderTest.java new file mode 100644 index 00000000..fd99a22b --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union1ReaderTest.java @@ -0,0 +1,24 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.common.utils.HexConverter; +import com.strategyobject.substrateclient.scale.readers.U8Reader; +import lombok.SneakyThrows; +import lombok.val; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayInputStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union1ReaderTest { + private final Union1Reader unionReader = new Union1Reader(); + + @SneakyThrows + @Test + void readItem0() { + val bytes = HexConverter.toBytes("0x002a"); + val stream = new ByteArrayInputStream(bytes); + val actual = unionReader.read(stream, new U8Reader()); + assertEquals(42, actual.getItem0()); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union2ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union2ReaderTest.java new file mode 100644 index 00000000..f441b5e9 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union2ReaderTest.java @@ -0,0 +1,35 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.common.utils.HexConverter; +import com.strategyobject.substrateclient.scale.readers.BoolReader; +import com.strategyobject.substrateclient.scale.readers.U8Reader; +import com.strategyobject.substrateclient.scale.readers.VoidReader; +import lombok.SneakyThrows; +import lombok.val; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayInputStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union2ReaderTest { + private final Union2Reader unionReader = new Union2Reader(); + + @SneakyThrows + @Test + void readItem0() { + val bytes = HexConverter.toBytes("0x002a"); + val stream = new ByteArrayInputStream(bytes); + val actual = unionReader.read(stream, new U8Reader(), new VoidReader()); + assertEquals(42, actual.getItem0()); + } + + @SneakyThrows + @Test + void readItem1() { + val bytes = HexConverter.toBytes("0x0101"); + val stream = new ByteArrayInputStream(bytes); + val actual = unionReader.read(stream, new VoidReader(), new BoolReader()); + assertEquals(true, actual.getItem1()); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union3ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union3ReaderTest.java new file mode 100644 index 00000000..514d2545 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union3ReaderTest.java @@ -0,0 +1,44 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.common.utils.HexConverter; +import com.strategyobject.substrateclient.scale.readers.BoolReader; +import com.strategyobject.substrateclient.scale.readers.U8Reader; +import com.strategyobject.substrateclient.scale.readers.VoidReader; +import lombok.SneakyThrows; +import lombok.val; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayInputStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union3ReaderTest { + private final Union3Reader unionReader = new Union3Reader(); + + @SneakyThrows + @Test + void readItem0() { + val bytes = HexConverter.toBytes("0x002a"); + val stream = new ByteArrayInputStream(bytes); + val actual = unionReader.read(stream, new U8Reader(), new VoidReader(), new VoidReader()); + assertEquals(42, actual.getItem0()); + } + + @SneakyThrows + @Test + void readItem1() { + val bytes = HexConverter.toBytes("0x0101"); + val stream = new ByteArrayInputStream(bytes); + val actual = unionReader.read(stream, new VoidReader(), new BoolReader(), new VoidReader()); + assertEquals(true, actual.getItem1()); + } + + @SneakyThrows + @Test + void readItem2() { + val bytes = HexConverter.toBytes("0x0201"); + val stream = new ByteArrayInputStream(bytes); + val actual = unionReader.read(stream, new VoidReader(), new VoidReader(), new U8Reader()); + assertEquals(1, actual.getItem2()); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union4ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union4ReaderTest.java new file mode 100644 index 00000000..fbba3e68 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union4ReaderTest.java @@ -0,0 +1,22 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union4; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union4ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union4Reader(), new Function[]{ + x -> ((Union4) x).getItem0(), + x -> ((Union4) x).getItem1(), + x -> ((Union4) x).getItem2(), + x -> ((Union4) x).getItem3() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union5ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union5ReaderTest.java new file mode 100644 index 00000000..b998f24d --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union5ReaderTest.java @@ -0,0 +1,23 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union5; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union5ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union5Reader(), new Function[]{ + x -> ((Union5) x).getItem0(), + x -> ((Union5) x).getItem1(), + x -> ((Union5) x).getItem2(), + x -> ((Union5) x).getItem3(), + x -> ((Union5) x).getItem4() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union6ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union6ReaderTest.java new file mode 100644 index 00000000..3f3218e0 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union6ReaderTest.java @@ -0,0 +1,24 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union6; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union6ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union6Reader(), new Function[]{ + x -> ((Union6) x).getItem0(), + x -> ((Union6) x).getItem1(), + x -> ((Union6) x).getItem2(), + x -> ((Union6) x).getItem3(), + x -> ((Union6) x).getItem4(), + x -> ((Union6) x).getItem5() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union7ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union7ReaderTest.java new file mode 100644 index 00000000..aed2d82f --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union7ReaderTest.java @@ -0,0 +1,25 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union7; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union7ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union7Reader(), new Function[]{ + x -> ((Union7) x).getItem0(), + x -> ((Union7) x).getItem1(), + x -> ((Union7) x).getItem2(), + x -> ((Union7) x).getItem3(), + x -> ((Union7) x).getItem4(), + x -> ((Union7) x).getItem5(), + x -> ((Union7) x).getItem6() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union8ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union8ReaderTest.java new file mode 100644 index 00000000..773497fb --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union8ReaderTest.java @@ -0,0 +1,26 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union8; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union8ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union8Reader(), new Function[]{ + x -> ((Union8) x).getItem0(), + x -> ((Union8) x).getItem1(), + x -> ((Union8) x).getItem2(), + x -> ((Union8) x).getItem3(), + x -> ((Union8) x).getItem4(), + x -> ((Union8) x).getItem5(), + x -> ((Union8) x).getItem6(), + x -> ((Union8) x).getItem7() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union9ReaderTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union9ReaderTest.java new file mode 100644 index 00000000..6e2c4f3a --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/Union9ReaderTest.java @@ -0,0 +1,27 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.types.union.Union9; +import lombok.SneakyThrows; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union9ReaderTest { + + @SuppressWarnings({"rawtypes"}) + @SneakyThrows + @Test + void read() { + UnionReaderTester.testRead(new Union9Reader(), new Function[]{ + x -> ((Union9) x).getItem0(), + x -> ((Union9) x).getItem1(), + x -> ((Union9) x).getItem2(), + x -> ((Union9) x).getItem3(), + x -> ((Union9) x).getItem4(), + x -> ((Union9) x).getItem5(), + x -> ((Union9) x).getItem6(), + x -> ((Union9) x).getItem7(), + x -> ((Union9) x).getItem8() + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/UnionReaderTester.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/UnionReaderTester.java new file mode 100644 index 00000000..c5fd980e --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/readers/union/UnionReaderTester.java @@ -0,0 +1,33 @@ +package com.strategyobject.substrateclient.scale.readers.union; + +import com.strategyobject.substrateclient.scale.ScaleReader; +import com.strategyobject.substrateclient.scale.readers.U8Reader; +import com.strategyobject.substrateclient.scale.readers.VoidReader; +import com.strategyobject.substrateclient.types.union.Union; +import lombok.SneakyThrows; +import lombok.val; +import lombok.var; + +import java.io.ByteArrayInputStream; +import java.util.Arrays; +import java.util.function.Function; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class UnionReaderTester { + + @SneakyThrows + @SuppressWarnings({"rawtypes", "unchecked"}) + static void testRead(ScaleReader reader, Function[] getters) { + for (var i = 0; i < getters.length; i++) { + byte[] bytes = {(byte) i, 1}; + val stream = new ByteArrayInputStream(bytes); + val readers = new ScaleReader[getters.length]; + Arrays.fill(readers, new VoidReader()); + readers[i] = new U8Reader(); + val actual = reader.read(stream, readers); + + assertEquals(1, getters[i].apply(actual)); + } + } +} diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union10WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union10WriterTest.java new file mode 100644 index 00000000..5ca18562 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union10WriterTest.java @@ -0,0 +1,26 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union10; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union10WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union10Writer(), new Function[]{ + Union10::withItem0, + Union10::withItem1, + Union10::withItem2, + Union10::withItem3, + Union10::withItem4, + Union10::withItem5, + Union10::withItem6, + Union10::withItem7, + Union10::withItem8, + Union10::withItem9 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union11WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union11WriterTest.java new file mode 100644 index 00000000..d1e5c37a --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union11WriterTest.java @@ -0,0 +1,27 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union11; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union11WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union11Writer(), new Function[]{ + Union11::withItem0, + Union11::withItem1, + Union11::withItem2, + Union11::withItem3, + Union11::withItem4, + Union11::withItem5, + Union11::withItem6, + Union11::withItem7, + Union11::withItem8, + Union11::withItem9, + Union11::withItem10 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union12WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union12WriterTest.java new file mode 100644 index 00000000..f18ed9fc --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union12WriterTest.java @@ -0,0 +1,28 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union12; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union12WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union12Writer(), new Function[]{ + Union12::withItem0, + Union12::withItem1, + Union12::withItem2, + Union12::withItem3, + Union12::withItem4, + Union12::withItem5, + Union12::withItem6, + Union12::withItem7, + Union12::withItem8, + Union12::withItem9, + Union12::withItem10, + Union12::withItem11 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union1WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union1WriterTest.java new file mode 100644 index 00000000..bed11352 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union1WriterTest.java @@ -0,0 +1,24 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.scale.writers.I8Writer; +import com.strategyobject.substrateclient.types.union.Union1; +import lombok.SneakyThrows; +import lombok.val; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +class Union1WriterTest { + private final Union1Writer unionWriter = new Union1Writer(); + + @SneakyThrows + @Test + void writeItem0() { + val stream = new ByteArrayOutputStream(); + unionWriter.write(Union1.withItem0((byte) 1), stream, new I8Writer()); + val actual = stream.toByteArray(); + assertArrayEquals(new byte[]{0, 1}, actual); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union2WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union2WriterTest.java new file mode 100644 index 00000000..f46cc8bb --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union2WriterTest.java @@ -0,0 +1,34 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.scale.writers.I8Writer; +import com.strategyobject.substrateclient.scale.writers.VoidWriter; +import com.strategyobject.substrateclient.types.union.Union2; +import lombok.SneakyThrows; +import lombok.val; +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +class Union2WriterTest { + private final Union2Writer unionWriter = new Union2Writer(); + + @SneakyThrows + @Test + void writeItem0() { + val stream = new ByteArrayOutputStream(); + unionWriter.write(Union2.withItem0((byte) 1), stream, new I8Writer(), new VoidWriter()); + val actual = stream.toByteArray(); + assertArrayEquals(new byte[]{0, 1}, actual); + } + + @SneakyThrows + @Test + void writeItem1() { + val stream = new ByteArrayOutputStream(); + unionWriter.write(Union2.withItem1((byte) 1), stream, new VoidWriter(), new I8Writer()); + val actual = stream.toByteArray(); + assertArrayEquals(new byte[]{1, 1}, actual); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union3WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union3WriterTest.java new file mode 100644 index 00000000..45098e12 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union3WriterTest.java @@ -0,0 +1,19 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union3; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union3WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union3Writer(), new Function[]{ + Union3::withItem0, + Union3::withItem1, + Union3::withItem2 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union4WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union4WriterTest.java new file mode 100644 index 00000000..dd40d326 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union4WriterTest.java @@ -0,0 +1,20 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union4; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union4WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union4Writer(), new Function[]{ + Union4::withItem0, + Union4::withItem1, + Union4::withItem2, + Union4::withItem3 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union5WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union5WriterTest.java new file mode 100644 index 00000000..45f1fa51 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union5WriterTest.java @@ -0,0 +1,21 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union5; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union5WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union5Writer(), new Function[]{ + Union5::withItem0, + Union5::withItem1, + Union5::withItem2, + Union5::withItem3, + Union5::withItem4 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union6WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union6WriterTest.java new file mode 100644 index 00000000..040d5e4a --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union6WriterTest.java @@ -0,0 +1,22 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union6; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union6WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union6Writer(), new Function[]{ + Union6::withItem0, + Union6::withItem1, + Union6::withItem2, + Union6::withItem3, + Union6::withItem4, + Union6::withItem5 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union7WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union7WriterTest.java new file mode 100644 index 00000000..8677a64c --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union7WriterTest.java @@ -0,0 +1,23 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union7; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union7WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union7Writer(), new Function[]{ + Union7::withItem0, + Union7::withItem1, + Union7::withItem2, + Union7::withItem3, + Union7::withItem4, + Union7::withItem5, + Union7::withItem6 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union8WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union8WriterTest.java new file mode 100644 index 00000000..c9939daa --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union8WriterTest.java @@ -0,0 +1,24 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union8; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union8WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union8Writer(), new Function[]{ + Union8::withItem0, + Union8::withItem1, + Union8::withItem2, + Union8::withItem3, + Union8::withItem4, + Union8::withItem5, + Union8::withItem6, + Union8::withItem7 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union9WriterTest.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union9WriterTest.java new file mode 100644 index 00000000..cc21f320 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/Union9WriterTest.java @@ -0,0 +1,25 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.types.union.Union9; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +class Union9WriterTest { + + @SuppressWarnings("unchecked") + @Test + void write() { + UnionWriterTester.testWrite(new Union9Writer(), new Function[]{ + Union9::withItem0, + Union9::withItem1, + Union9::withItem2, + Union9::withItem3, + Union9::withItem4, + Union9::withItem5, + Union9::withItem6, + Union9::withItem7, + Union9::withItem8 + }); + } +} \ No newline at end of file diff --git a/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/UnionWriterTester.java b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/UnionWriterTester.java new file mode 100644 index 00000000..142e3db8 --- /dev/null +++ b/scale/src/test/java/com/strategyobject/substrateclient/scale/writers/union/UnionWriterTester.java @@ -0,0 +1,33 @@ +package com.strategyobject.substrateclient.scale.writers.union; + +import com.strategyobject.substrateclient.scale.ScaleWriter; +import com.strategyobject.substrateclient.scale.writers.I8Writer; +import com.strategyobject.substrateclient.scale.writers.VoidWriter; +import com.strategyobject.substrateclient.types.union.Union; +import lombok.SneakyThrows; +import lombok.val; +import lombok.var; + +import java.io.ByteArrayOutputStream; +import java.util.Arrays; +import java.util.function.Function; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + +public class UnionWriterTester { + + @SneakyThrows + static void testWrite(ScaleWriter writer, Function[] creators) { + for (var i = 0; i < creators.length; i++) { + val stream = new ByteArrayOutputStream(); + val writers = new ScaleWriter[creators.length]; + Arrays.fill(writers, new VoidWriter()); + writers[i] = new I8Writer(); + val union = creators[i].apply((byte) 1); + writer.write(union, stream, writers); + val actual = stream.toByteArray(); + + assertArrayEquals(new byte[]{(byte) i, 1}, actual); + } + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union.java new file mode 100644 index 00000000..7a0c24a4 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union.java @@ -0,0 +1,10 @@ +package com.strategyobject.substrateclient.types.union; + +public abstract class Union { + protected int index; + protected Object value; + + public int getIndex() { + return index; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union1.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union1.java new file mode 100644 index 00000000..966238a8 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union1.java @@ -0,0 +1,27 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union1 extends Union { + private Union1() { + } + + public T match(@NonNull Function f0) { + return f0.apply(getItem0()); + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + return (T0) value; + } + + public static Union1 withItem0(T0 item0) { + val result = new Union1(); + result.value = item0; + result.index = 0; + return result; + } +} \ No newline at end of file diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union10.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union10.java new file mode 100644 index 00000000..0e17291c --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union10.java @@ -0,0 +1,176 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union10 extends Union { + private Union10() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5, + @NonNull Function f6, + @NonNull Function f7, + @NonNull Function f8, + @NonNull Function f9) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + case 5: + return f5.apply(getItem5()); + case 6: + return f6.apply(getItem6()); + case 7: + return f7.apply(getItem7()); + case 8: + return f8.apply(getItem8()); + default: + return f9.apply(getItem9()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + @SuppressWarnings("unchecked") + public T6 getItem6() { + Preconditions.checkState(index == 6); + return (T6) value; + } + + @SuppressWarnings("unchecked") + public T7 getItem7() { + Preconditions.checkState(index == 7); + return (T7) value; + } + + @SuppressWarnings("unchecked") + public T8 getItem8() { + Preconditions.checkState(index == 8); + return (T8) value; + } + + @SuppressWarnings("unchecked") + public T9 getItem9() { + Preconditions.checkState(index == 9); + return (T9) value; + } + + public static Union10 withItem0(T0 item0) { + val result = new Union10(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union10 withItem1(T1 item1) { + val result = new Union10(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union10 withItem2(T2 item2) { + val result = new Union10(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union10 withItem3(T3 item3) { + val result = new Union10(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union10 withItem4(T4 item4) { + val result = new Union10(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union10 withItem5(T5 item5) { + val result = new Union10(); + result.value = item5; + result.index = 5; + return result; + } + + public static Union10 withItem6(T6 item6) { + val result = new Union10(); + result.value = item6; + result.index = 6; + return result; + } + + public static Union10 withItem7(T7 item7) { + val result = new Union10(); + result.value = item7; + result.index = 7; + return result; + } + + public static Union10 withItem8(T8 item8) { + val result = new Union10(); + result.value = item8; + result.index = 8; + return result; + } + + public static Union10 withItem9(T9 item9) { + val result = new Union10(); + result.value = item9; + result.index = 9; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union11.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union11.java new file mode 100644 index 00000000..15777e79 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union11.java @@ -0,0 +1,192 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union11 extends Union { + private Union11() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5, + @NonNull Function f6, + @NonNull Function f7, + @NonNull Function f8, + @NonNull Function f9, + @NonNull Function f10) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + case 5: + return f5.apply(getItem5()); + case 6: + return f6.apply(getItem6()); + case 7: + return f7.apply(getItem7()); + case 8: + return f8.apply(getItem8()); + case 9: + return f9.apply(getItem9()); + default: + return f10.apply(getItem10()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + @SuppressWarnings("unchecked") + public T6 getItem6() { + Preconditions.checkState(index == 6); + return (T6) value; + } + + @SuppressWarnings("unchecked") + public T7 getItem7() { + Preconditions.checkState(index == 7); + return (T7) value; + } + + @SuppressWarnings("unchecked") + public T8 getItem8() { + Preconditions.checkState(index == 8); + return (T8) value; + } + + @SuppressWarnings("unchecked") + public T9 getItem9() { + Preconditions.checkState(index == 9); + return (T9) value; + } + + @SuppressWarnings("unchecked") + public T10 getItem10() { + Preconditions.checkState(index == 10); + return (T10) value; + } + + public static Union11 withItem0(T0 item0) { + val result = new Union11(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union11 withItem1(T1 item1) { + val result = new Union11(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union11 withItem2(T2 item2) { + val result = new Union11(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union11 withItem3(T3 item3) { + val result = new Union11(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union11 withItem4(T4 item4) { + val result = new Union11(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union11 withItem5(T5 item5) { + val result = new Union11(); + result.value = item5; + result.index = 5; + return result; + } + + public static Union11 withItem6(T6 item6) { + val result = new Union11(); + result.value = item6; + result.index = 6; + return result; + } + + public static Union11 withItem7(T7 item7) { + val result = new Union11(); + result.value = item7; + result.index = 7; + return result; + } + + public static Union11 withItem8(T8 item8) { + val result = new Union11(); + result.value = item8; + result.index = 8; + return result; + } + + public static Union11 withItem9(T9 item9) { + val result = new Union11(); + result.value = item9; + result.index = 9; + return result; + } + + public static Union11 withItem10(T10 item10) { + val result = new Union11(); + result.value = item10; + result.index = 10; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union12.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union12.java new file mode 100644 index 00000000..07bfe149 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union12.java @@ -0,0 +1,208 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union12 extends Union { + private Union12() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5, + @NonNull Function f6, + @NonNull Function f7, + @NonNull Function f8, + @NonNull Function f9, + @NonNull Function f10, + @NonNull Function f11) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + case 5: + return f5.apply(getItem5()); + case 6: + return f6.apply(getItem6()); + case 7: + return f7.apply(getItem7()); + case 8: + return f8.apply(getItem8()); + case 9: + return f9.apply(getItem9()); + case 10: + return f10.apply(getItem10()); + default: + return f11.apply(getItem11()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + @SuppressWarnings("unchecked") + public T6 getItem6() { + Preconditions.checkState(index == 6); + return (T6) value; + } + + @SuppressWarnings("unchecked") + public T7 getItem7() { + Preconditions.checkState(index == 7); + return (T7) value; + } + + @SuppressWarnings("unchecked") + public T8 getItem8() { + Preconditions.checkState(index == 8); + return (T8) value; + } + + @SuppressWarnings("unchecked") + public T9 getItem9() { + Preconditions.checkState(index == 9); + return (T9) value; + } + + @SuppressWarnings("unchecked") + public T10 getItem10() { + Preconditions.checkState(index == 10); + return (T10) value; + } + + @SuppressWarnings("unchecked") + public T11 getItem11() { + Preconditions.checkState(index == 11); + return (T11) value; + } + + public static Union12 withItem0(T0 item0) { + val result = new Union12(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union12 withItem1(T1 item1) { + val result = new Union12(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union12 withItem2(T2 item2) { + val result = new Union12(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union12 withItem3(T3 item3) { + val result = new Union12(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union12 withItem4(T4 item4) { + val result = new Union12(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union12 withItem5(T5 item5) { + val result = new Union12(); + result.value = item5; + result.index = 5; + return result; + } + + public static Union12 withItem6(T6 item6) { + val result = new Union12(); + result.value = item6; + result.index = 6; + return result; + } + + public static Union12 withItem7(T7 item7) { + val result = new Union12(); + result.value = item7; + result.index = 7; + return result; + } + + public static Union12 withItem8(T8 item8) { + val result = new Union12(); + result.value = item8; + result.index = 8; + return result; + } + + public static Union12 withItem9(T9 item9) { + val result = new Union12(); + result.value = item9; + result.index = 9; + return result; + } + + public static Union12 withItem10(T10 item10) { + val result = new Union12(); + result.value = item10; + result.index = 10; + return result; + } + + public static Union12 withItem11(T11 item11) { + val result = new Union12(); + result.value = item11; + result.index = 11; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union2.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union2.java new file mode 100644 index 00000000..3bd1608d --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union2.java @@ -0,0 +1,42 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union2 extends Union { + private Union2() { + } + + public T match(@NonNull Function f0, @NonNull Function f1) { + return index == 0 ? f0.apply(getItem0()) : f1.apply(getItem1()); + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + public static Union2 withItem0(T0 item0) { + val result = new Union2(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union2 withItem1(T1 item1) { + val result = new Union2(); + result.value = item1; + result.index = 1; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union3.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union3.java new file mode 100644 index 00000000..6627d8c4 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union3.java @@ -0,0 +1,64 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union3 extends Union { + private Union3() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + default: + return f2.apply(getItem2()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + public static Union3 withItem0(T0 item0) { + val result = new Union3(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union3 withItem1(T1 item1) { + val result = new Union3(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union3 withItem2(T2 item2) { + val result = new Union3(); + result.value = item2; + result.index = 2; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union4.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union4.java new file mode 100644 index 00000000..137720aa --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union4.java @@ -0,0 +1,80 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union4 extends Union { + private Union4() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + default: + return f3.apply(getItem3()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + public static Union4 withItem0(T0 item0) { + val result = new Union4(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union4 withItem1(T1 item1) { + val result = new Union4(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union4 withItem2(T2 item2) { + val result = new Union4(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union4 withItem3(T3 item3) { + val result = new Union4(); + result.value = item3; + result.index = 3; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union5.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union5.java new file mode 100644 index 00000000..e25c7435 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union5.java @@ -0,0 +1,96 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union5 extends Union { + private Union5() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + default: + return f4.apply(getItem4()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + public static Union5 withItem0(T0 item0) { + val result = new Union5(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union5 withItem1(T1 item1) { + val result = new Union5(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union5 withItem2(T2 item2) { + val result = new Union5(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union5 withItem3(T3 item3) { + val result = new Union5(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union5 withItem4(T4 item4) { + val result = new Union5(); + result.value = item4; + result.index = 4; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union6.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union6.java new file mode 100644 index 00000000..fc864618 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union6.java @@ -0,0 +1,112 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union6 extends Union { + private Union6() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + default: + return f5.apply(getItem5()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + public static Union6 withItem0(T0 item0) { + val result = new Union6(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union6 withItem1(T1 item1) { + val result = new Union6(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union6 withItem2(T2 item2) { + val result = new Union6(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union6 withItem3(T3 item3) { + val result = new Union6(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union6 withItem4(T4 item4) { + val result = new Union6(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union6 withItem5(T5 item5) { + val result = new Union6(); + result.value = item5; + result.index = 5; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union7.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union7.java new file mode 100644 index 00000000..0bd0ebf3 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union7.java @@ -0,0 +1,128 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union7 extends Union { + private Union7() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5, + @NonNull Function f6) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + case 5: + return f5.apply(getItem5()); + default: + return f6.apply(getItem6()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + @SuppressWarnings("unchecked") + public T6 getItem6() { + Preconditions.checkState(index == 6); + return (T6) value; + } + + public static Union7 withItem0(T0 item0) { + val result = new Union7(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union7 withItem1(T1 item1) { + val result = new Union7(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union7 withItem2(T2 item2) { + val result = new Union7(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union7 withItem3(T3 item3) { + val result = new Union7(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union7 withItem4(T4 item4) { + val result = new Union7(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union7 withItem5(T5 item5) { + val result = new Union7(); + result.value = item5; + result.index = 5; + return result; + } + + public static Union7 withItem6(T6 item6) { + val result = new Union7(); + result.value = item6; + result.index = 6; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union8.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union8.java new file mode 100644 index 00000000..91157fdc --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union8.java @@ -0,0 +1,144 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union8 extends Union { + private Union8() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5, + @NonNull Function f6, + @NonNull Function f7) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + case 5: + return f5.apply(getItem5()); + case 6: + return f6.apply(getItem6()); + default: + return f7.apply(getItem7()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + @SuppressWarnings("unchecked") + public T6 getItem6() { + Preconditions.checkState(index == 6); + return (T6) value; + } + + @SuppressWarnings("unchecked") + public T7 getItem7() { + Preconditions.checkState(index == 7); + return (T7) value; + } + + public static Union8 withItem0(T0 item0) { + val result = new Union8(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union8 withItem1(T1 item1) { + val result = new Union8(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union8 withItem2(T2 item2) { + val result = new Union8(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union8 withItem3(T3 item3) { + val result = new Union8(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union8 withItem4(T4 item4) { + val result = new Union8(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union8 withItem5(T5 item5) { + val result = new Union8(); + result.value = item5; + result.index = 5; + return result; + } + + public static Union8 withItem6(T6 item6) { + val result = new Union8(); + result.value = item6; + result.index = 6; + return result; + } + + public static Union8 withItem7(T7 item7) { + val result = new Union8(); + result.value = item7; + result.index = 7; + return result; + } +} diff --git a/types/src/main/java/com/strategyobject/substrateclient/types/union/Union9.java b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union9.java new file mode 100644 index 00000000..c2ae5055 --- /dev/null +++ b/types/src/main/java/com/strategyobject/substrateclient/types/union/Union9.java @@ -0,0 +1,160 @@ +package com.strategyobject.substrateclient.types.union; + +import com.google.common.base.Preconditions; +import lombok.NonNull; +import lombok.val; + +import java.util.function.Function; + +public class Union9 extends Union { + private Union9() { + } + + public T match(@NonNull Function f0, + @NonNull Function f1, + @NonNull Function f2, + @NonNull Function f3, + @NonNull Function f4, + @NonNull Function f5, + @NonNull Function f6, + @NonNull Function f7, + @NonNull Function f8) { + switch (index) { + case 0: + return f0.apply(getItem0()); + case 1: + return f1.apply(getItem1()); + case 2: + return f2.apply(getItem2()); + case 3: + return f3.apply(getItem3()); + case 4: + return f4.apply(getItem4()); + case 5: + return f5.apply(getItem5()); + case 6: + return f6.apply(getItem6()); + case 7: + return f7.apply(getItem7()); + default: + return f8.apply(getItem8()); + } + } + + @SuppressWarnings("unchecked") + public T0 getItem0() { + Preconditions.checkState(index == 0); + return (T0) value; + } + + @SuppressWarnings("unchecked") + public T1 getItem1() { + Preconditions.checkState(index == 1); + return (T1) value; + } + + @SuppressWarnings("unchecked") + public T2 getItem2() { + Preconditions.checkState(index == 2); + return (T2) value; + } + + @SuppressWarnings("unchecked") + public T3 getItem3() { + Preconditions.checkState(index == 3); + return (T3) value; + } + + @SuppressWarnings("unchecked") + public T4 getItem4() { + Preconditions.checkState(index == 4); + return (T4) value; + } + + @SuppressWarnings("unchecked") + public T5 getItem5() { + Preconditions.checkState(index == 5); + return (T5) value; + } + + @SuppressWarnings("unchecked") + public T6 getItem6() { + Preconditions.checkState(index == 6); + return (T6) value; + } + + @SuppressWarnings("unchecked") + public T7 getItem7() { + Preconditions.checkState(index == 7); + return (T7) value; + } + + @SuppressWarnings("unchecked") + public T8 getItem8() { + Preconditions.checkState(index == 8); + return (T8) value; + } + + public static Union9 withItem0(T0 item0) { + val result = new Union9(); + result.value = item0; + result.index = 0; + return result; + } + + public static Union9 withItem1(T1 item1) { + val result = new Union9(); + result.value = item1; + result.index = 1; + return result; + } + + public static Union9 withItem2(T2 item2) { + val result = new Union9(); + result.value = item2; + result.index = 2; + return result; + } + + public static Union9 withItem3(T3 item3) { + val result = new Union9(); + result.value = item3; + result.index = 3; + return result; + } + + public static Union9 withItem4(T4 item4) { + val result = new Union9(); + result.value = item4; + result.index = 4; + return result; + } + + public static Union9 withItem5(T5 item5) { + val result = new Union9(); + result.value = item5; + result.index = 5; + return result; + } + + public static Union9 withItem6(T6 item6) { + val result = new Union9(); + result.value = item6; + result.index = 6; + return result; + } + + public static Union9 withItem7(T7 item7) { + val result = new Union9(); + result.value = item7; + result.index = 7; + return result; + } + + public static Union9 withItem8(T8 item8) { + val result = new Union9(); + result.value = item8; + result.index = 8; + return result; + } +} diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union10Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union10Test.java new file mode 100644 index 00000000..abf62b66 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union10Test.java @@ -0,0 +1,227 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union10Test { + + @Test + void getItem0() { + val expected = false; + val union = Union10.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union10.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union10.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union10.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem4() { + val expected = true; + val union = Union10.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union10.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem6() { + val expected = "6"; + val union = Union10.withItem6(expected); + + Assertions.assertEquals(6, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertEquals(expected, union.getItem6()); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem7() { + val expected = 7f; + val union = Union10.withItem7(expected); + + Assertions.assertEquals(7, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertEquals(expected, union.getItem7()); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem8() { + val expected = false; + val union = Union10.withItem8(expected); + + Assertions.assertEquals(8, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertEquals(expected, union.getItem8()); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + } + + @Test + void getItem9() { + val expected = 9; + val union = Union10.withItem9(expected); + + Assertions.assertEquals(9, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertEquals(expected, union.getItem9()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union10::withItem0, + Union10::withItem1, + Union10::withItem2, + Union10::withItem3, + Union10::withItem4, + Union10::withItem5, + Union10::withItem6, + Union10::withItem7, + Union10::withItem8, + Union10::withItem9 + }; + + IntStream.range(0, 10).forEach(expected -> { + val union = (Union10) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union11Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union11Test.java new file mode 100644 index 00000000..19a501db --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union11Test.java @@ -0,0 +1,258 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union11Test { + + @Test + void getItem0() { + val expected = false; + val union = Union11.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union11.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union11.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union11.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem4() { + val expected = true; + val union = Union11.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union11.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem6() { + val expected = "6"; + val union = Union11.withItem6(expected); + + Assertions.assertEquals(6, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertEquals(expected, union.getItem6()); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem7() { + val expected = 7f; + val union = Union11.withItem7(expected); + + Assertions.assertEquals(7, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertEquals(expected, union.getItem7()); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem8() { + val expected = false; + val union = Union11.withItem8(expected); + + Assertions.assertEquals(8, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertEquals(expected, union.getItem8()); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem9() { + val expected = 9; + val union = Union11.withItem9(expected); + + Assertions.assertEquals(9, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertEquals(expected, union.getItem9()); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + } + + @Test + void getItem10() { + val expected = "10"; + val union = Union11.withItem10(expected); + + Assertions.assertEquals(10, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertEquals(expected, union.getItem10()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union11::withItem0, + Union11::withItem1, + Union11::withItem2, + Union11::withItem3, + Union11::withItem4, + Union11::withItem5, + Union11::withItem6, + Union11::withItem7, + Union11::withItem8, + Union11::withItem9, + Union11::withItem10 + }; + + IntStream.range(0, 11).forEach(expected -> { + val union = (Union11) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union12Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union12Test.java new file mode 100644 index 00000000..06132bcd --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union12Test.java @@ -0,0 +1,291 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union12Test { + + @Test + void getItem0() { + val expected = false; + val union = Union12.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union12.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union12.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union12.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem4() { + val expected = true; + val union = Union12.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union12.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem6() { + val expected = "6"; + val union = Union12.withItem6(expected); + + Assertions.assertEquals(6, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertEquals(expected, union.getItem6()); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem7() { + val expected = 7f; + val union = Union12.withItem7(expected); + + Assertions.assertEquals(7, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertEquals(expected, union.getItem7()); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem8() { + val expected = false; + val union = Union12.withItem8(expected); + + Assertions.assertEquals(8, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertEquals(expected, union.getItem8()); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem9() { + val expected = 9; + val union = Union12.withItem9(expected); + + Assertions.assertEquals(9, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertEquals(expected, union.getItem9()); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem10() { + val expected = "10"; + val union = Union12.withItem10(expected); + + Assertions.assertEquals(10, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertEquals(expected, union.getItem10()); + Assertions.assertThrows(IllegalStateException.class, union::getItem11); + } + + @Test + void getItem11() { + val expected = 11f; + val union = Union12.withItem11(expected); + + Assertions.assertEquals(11, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + Assertions.assertThrows(IllegalStateException.class, union::getItem9); + Assertions.assertThrows(IllegalStateException.class, union::getItem10); + Assertions.assertEquals(expected, union.getItem11()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union12::withItem0, + Union12::withItem1, + Union12::withItem2, + Union12::withItem3, + Union12::withItem4, + Union12::withItem5, + Union12::withItem6, + Union12::withItem7, + Union12::withItem8, + Union12::withItem9, + Union12::withItem10, + Union12::withItem11 + }; + + IntStream.range(0, 12).forEach(expected -> { + val union = (Union12) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union1Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union1Test.java new file mode 100644 index 00000000..b67b438b --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union1Test.java @@ -0,0 +1,28 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union1Test { + + @Test + void getItem0() { + val expected = false; + val union = Union1.withItem0(expected); + + assertEquals(0, union.getIndex()); + assertEquals(expected, union.getItem0()); + } + + @Test + void match() { + val expected = 0; + val union = Union1.withItem0(expected); + + assertEquals(expected, union.match(Function.identity())); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union2Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union2Test.java new file mode 100644 index 00000000..4aa50217 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union2Test.java @@ -0,0 +1,44 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union2Test { + + @Test + void getItem0() { + val expected = false; + val union = Union2.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union2.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = {Union2::withItem0, Union2::withItem1}; + IntStream.range(0, 2).forEach(expected -> { + val union = (Union2) creators[expected].apply(expected); + + assertEquals(expected, union.match(Function.identity(), Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union3Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union3Test.java new file mode 100644 index 00000000..665f36e1 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union3Test.java @@ -0,0 +1,66 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union3Test { + + @Test + void getItem0() { + val expected = false; + val union = Union3.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union3.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union3.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union3::withItem0, + Union3::withItem1, + Union3::withItem2 + }; + + IntStream.range(0, 3).forEach(expected -> { + val union = (Union3) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union4Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union4Test.java new file mode 100644 index 00000000..b2302ba1 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union4Test.java @@ -0,0 +1,83 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union4Test { + + @Test + void getItem0() { + val expected = false; + val union = Union4.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union4.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union4.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union4.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union4::withItem0, + Union4::withItem1, + Union4::withItem2, + Union4::withItem3 + }; + + IntStream.range(0, 4).forEach(expected -> { + val union = (Union4) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union5Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union5Test.java new file mode 100644 index 00000000..cd727b91 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union5Test.java @@ -0,0 +1,102 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union5Test { + + @Test + void getItem0() { + val expected = false; + val union = Union5.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union5.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union5.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union5.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + } + + @Test + void getItem4() { + val expected = true; + val union = Union5.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union5::withItem0, + Union5::withItem1, + Union5::withItem2, + Union5::withItem3, + Union5::withItem4 + }; + + IntStream.range(0, 5).forEach(expected -> { + val union = (Union5) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union6Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union6Test.java new file mode 100644 index 00000000..231d1d7b --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union6Test.java @@ -0,0 +1,123 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union6Test { + + @Test + void getItem0() { + val expected = false; + val union = Union6.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union6.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union6.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union6.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + } + + @Test + void getItem4() { + val expected = true; + val union = Union6.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union6.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union6::withItem0, + Union6::withItem1, + Union6::withItem2, + Union6::withItem3, + Union6::withItem4, + Union6::withItem5 + }; + + IntStream.range(0, 6).forEach(expected -> { + val union = (Union6) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union7Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union7Test.java new file mode 100644 index 00000000..c5460bc7 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union7Test.java @@ -0,0 +1,146 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union7Test { + + @Test + void getItem0() { + val expected = false; + val union = Union7.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union7.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union7.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union7.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + } + + @Test + void getItem4() { + val expected = true; + val union = Union7.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union7.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + } + + @Test + void getItem6() { + val expected = 6f; + val union = Union7.withItem6(expected); + + Assertions.assertEquals(6, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertEquals(expected, union.getItem6()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union7::withItem0, + Union7::withItem1, + Union7::withItem2, + Union7::withItem3, + Union7::withItem4, + Union7::withItem5, + Union7::withItem6 + }; + + IntStream.range(0, 7).forEach(expected -> { + val union = (Union7) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union8Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union8Test.java new file mode 100644 index 00000000..e78f75aa --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union8Test.java @@ -0,0 +1,171 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union8Test { + + @Test + void getItem0() { + val expected = false; + val union = Union8.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union8.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union8.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union8.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem4() { + val expected = true; + val union = Union8.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union8.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem6() { + val expected = 6f; + val union = Union8.withItem6(expected); + + Assertions.assertEquals(6, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertEquals(expected, union.getItem6()); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + } + + @Test + void getItem7() { + val expected = false; + val union = Union8.withItem7(expected); + + Assertions.assertEquals(7, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertEquals(expected, union.getItem7()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union8::withItem0, + Union8::withItem1, + Union8::withItem2, + Union8::withItem3, + Union8::withItem4, + Union8::withItem5, + Union8::withItem6, + Union8::withItem7 + }; + + IntStream.range(0, 8).forEach(expected -> { + val union = (Union8) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file diff --git a/types/src/test/java/com/strategyobject/substrateclient/types/union/Union9Test.java b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union9Test.java new file mode 100644 index 00000000..8b69c368 --- /dev/null +++ b/types/src/test/java/com/strategyobject/substrateclient/types/union/Union9Test.java @@ -0,0 +1,198 @@ +package com.strategyobject.substrateclient.types.union; + +import lombok.val; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +import java.util.function.Function; +import java.util.stream.IntStream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class Union9Test { + + @Test + void getItem0() { + val expected = false; + val union = Union9.withItem0(expected); + + Assertions.assertEquals(0, union.getIndex()); + Assertions.assertEquals(expected, union.getItem0()); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem1() { + val expected = 1; + val union = Union9.withItem1(expected); + + Assertions.assertEquals(1, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertEquals(expected, union.getItem1()); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem2() { + val expected = "2"; + val union = Union9.withItem2(expected); + + Assertions.assertEquals(2, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertEquals(expected, union.getItem2()); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem3() { + val expected = 3f; + val union = Union9.withItem3(expected); + + Assertions.assertEquals(3, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertEquals(expected, union.getItem3()); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem4() { + val expected = true; + val union = Union9.withItem4(expected); + + Assertions.assertEquals(4, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertEquals(expected, union.getItem4()); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem5() { + val expected = 5; + val union = Union9.withItem5(expected); + + Assertions.assertEquals(5, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertEquals(expected, union.getItem5()); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem6() { + val expected = "6"; + val union = Union9.withItem6(expected); + + Assertions.assertEquals(6, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertEquals(expected, union.getItem6()); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem7() { + val expected = false; + val union = Union9.withItem7(expected); + + Assertions.assertEquals(7, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertEquals(expected, union.getItem7()); + Assertions.assertThrows(IllegalStateException.class, union::getItem8); + } + + @Test + void getItem8() { + val expected = 8; + val union = Union9.withItem8(expected); + + Assertions.assertEquals(8, union.getIndex()); + Assertions.assertThrows(IllegalStateException.class, union::getItem0); + Assertions.assertThrows(IllegalStateException.class, union::getItem1); + Assertions.assertThrows(IllegalStateException.class, union::getItem2); + Assertions.assertThrows(IllegalStateException.class, union::getItem3); + Assertions.assertThrows(IllegalStateException.class, union::getItem4); + Assertions.assertThrows(IllegalStateException.class, union::getItem5); + Assertions.assertThrows(IllegalStateException.class, union::getItem6); + Assertions.assertThrows(IllegalStateException.class, union::getItem7); + Assertions.assertEquals(expected, union.getItem8()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Test + void match() { + Function[] creators = { + Union9::withItem0, + Union9::withItem1, + Union9::withItem2, + Union9::withItem3, + Union9::withItem4, + Union9::withItem5, + Union9::withItem6, + Union9::withItem7, + Union9::withItem8 + }; + + IntStream.range(0, 9).forEach(expected -> { + val union = (Union9) creators[expected].apply(expected); + + assertEquals(expected, + union.match( + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity(), + Function.identity())); + }); + } +} \ No newline at end of file