diff --git a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOread.java b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOread.java index 9db74d99d65..07f28d7a2c1 100644 --- a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOread.java +++ b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOread.java @@ -32,7 +32,7 @@ import org.eolang.Atom; import org.eolang.Attr; import org.eolang.Data; -import org.eolang.Dataized; +import org.eolang.Expect; import org.eolang.PhDefault; import org.eolang.Phi; import org.eolang.XmirObject; @@ -58,9 +58,9 @@ public final class EOmalloc$EOof$EOallocated$EOread extends PhDefault implements public Phi lambda() { return new Data.ToPhi( Heaps.INSTANCE.read( - new Dataized(this.take(Attr.RHO).take("id")).asNumber().intValue(), - new Dataized(this.take("offset")).asNumber().intValue(), - new Dataized(this.take("length")).asNumber().intValue() + new Expect.Natural(Expect.at(this.take(Attr.RHO), "id")).it(), + new Expect.Natural(Expect.at(this, "offset")).it(), + new Expect.Natural(Expect.at(this, "length")).it() ) ); } diff --git a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresized.java b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresized.java index e38356e8466..c2beaac86f5 100644 --- a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresized.java +++ b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresized.java @@ -31,7 +31,6 @@ import org.eolang.AtVoid; import org.eolang.Atom; import org.eolang.Attr; -import org.eolang.Dataized; import org.eolang.Expect; import org.eolang.PhDefault; import org.eolang.Phi; @@ -56,16 +55,8 @@ public final class EOmalloc$EOof$EOallocated$EOresized extends PhDefault impleme @Override public Phi lambda() { final Phi rho = this.take(Attr.RHO); - final int id = Expect.at(rho, "id") - .that(phi -> new Dataized(phi).asNumber()) - .otherwise("must be a number") - .that(Double::intValue) - .it(); - final int size = Expect.at(this, "new-size") - .that(phi -> new Dataized(phi).asNumber()) - .otherwise("must be a number") - .that(Double::intValue) - .it(); + final int id = new Expect.Natural(Expect.at(rho, "id")).it(); + final int size = new Expect.Natural(Expect.at(this, "new-size")).it(); Heaps.INSTANCE.resize(id, size); return rho; } diff --git a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOsize.java b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOsize.java index b803eb630ee..da478258ca1 100644 --- a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOsize.java +++ b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOsize.java @@ -31,7 +31,7 @@ import org.eolang.Atom; import org.eolang.Attr; import org.eolang.Data; -import org.eolang.Dataized; +import org.eolang.Expect; import org.eolang.PhDefault; import org.eolang.Phi; import org.eolang.XmirObject; @@ -48,7 +48,7 @@ public final class EOmalloc$EOof$EOallocated$EOsize extends PhDefault implements public Phi lambda() { return new Data.ToPhi( Heaps.INSTANCE.size( - new Dataized(this.take(Attr.RHO).take("id")).asNumber().intValue() + new Expect.Natural(Expect.at(this.take(Attr.RHO), "id")).it() ) ); } diff --git a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOwrite.java b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOwrite.java index 8e3d9fc515b..73a4076c7e0 100644 --- a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOwrite.java +++ b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOwrite.java @@ -33,6 +33,7 @@ import org.eolang.Attr; import org.eolang.Data; import org.eolang.Dataized; +import org.eolang.Expect; import org.eolang.PhDefault; import org.eolang.Phi; import org.eolang.XmirObject; @@ -57,8 +58,8 @@ public final class EOmalloc$EOof$EOallocated$EOwrite extends PhDefault implement @Override public Phi lambda() { Heaps.INSTANCE.write( - new Dataized(this.take(Attr.RHO).take("id")).asNumber().intValue(), - new Dataized(this.take("offset")).asNumber().intValue(), + new Expect.Natural(Expect.at(this.take(Attr.RHO), "id")).it(), + new Expect.Natural(Expect.at(this, "offset")).it(), new Dataized(this.take("data")).take() ); return new Data.ToPhi(true); diff --git "a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206.java" "b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206.java" index cd89282645c..e66bd1db4f0 100644 --- "a/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206.java" +++ "b/eo-runtime/src/main/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206.java" @@ -32,6 +32,7 @@ import org.eolang.Attr; import org.eolang.Data; import org.eolang.Dataized; +import org.eolang.Expect; import org.eolang.PhDefault; import org.eolang.Phi; import org.eolang.XmirObject; @@ -48,7 +49,7 @@ public final class EOmalloc$EOof$EOφ extends PhDefault implements Atom { public Phi lambda() { final Phi rho = this.take(Attr.RHO); final int identifier = Heaps.INSTANCE.malloc( - this, new Dataized(rho.take("size")).asNumber().intValue() + this, new Expect.Natural(Expect.at(rho, "size")).it() ); final Phi res; try { diff --git a/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOreadTest.java b/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOreadTest.java new file mode 100644 index 00000000000..717ac721ef3 --- /dev/null +++ b/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOreadTest.java @@ -0,0 +1,124 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2016-2025 Objectionary.com + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* + * @checkstyle PackageNameCheck (4 lines) + * @checkstyle TrailingCommentCheck (3 lines) + */ +package EOorg.EOeolang; // NOPMD + +import org.eolang.Data; +import org.eolang.Dataized; +import org.eolang.ExAbstract; +import org.eolang.PhWith; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link EOmalloc$EOof$EOallocated$EOread}. + * + * @since 0.52 + * @checkstyle TypeNameCheck (5 lines) + */ +@SuppressWarnings("PMD.AvoidDollarSigns") +final class EOmalloc$EOof$EOallocated$EOreadTest { + + @Test + void throwsCorrectErrorForLengthAttrNaN() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new PhWith( + new EOmallocTest.PhiWithIdDummy( + new EOmalloc$EOof$EOallocated$EOread() + ).it(), + "offset", + new Data.ToPhi(42) + ), + "length", + new Data.ToPhi(true) + ) + ).take(), + "put TRUE in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'length' attribute must be a number") + ); + } + + @Test + void throwsCorrectErrorForLengthAttrNotAnInt() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new PhWith( + new EOmallocTest.PhiWithIdDummy( + new EOmalloc$EOof$EOallocated$EOread() + ).it(), + "offset", + new Data.ToPhi(42) + ), + "length", + new Data.ToPhi(42.42) + ) + ).take(), + "put double in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'length' attribute (42.42) must be an integer") + ); + } + + @Test + void throwsCorrectErrorForLengthAttrNotNatural() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new PhWith( + new EOmallocTest.PhiWithIdDummy( + new EOmalloc$EOof$EOallocated$EOread() + ).it(), + "offset", + new Data.ToPhi(42) + ), + "length", + new Data.ToPhi(-42) + ) + ).take(), + "put negative int in natural attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'length' attribute (-42) must be greater or equal to zero") + ); + } + +} diff --git a/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresizedTest.java b/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresizedTest.java new file mode 100644 index 00000000000..4ea1dcccad4 --- /dev/null +++ b/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EOallocated$EOresizedTest.java @@ -0,0 +1,112 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2016-2025 Objectionary.com + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* + * @checkstyle PackageNameCheck (4 lines) + * @checkstyle TrailingCommentCheck (3 lines) + */ +package EOorg.EOeolang; // NOPMD + +import org.eolang.Data; +import org.eolang.Dataized; +import org.eolang.ExAbstract; +import org.eolang.PhWith; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +/** + * Test case for {@link EOmalloc$EOof$EOallocated$EOresized}. + * + * @since 0.52 + * @checkstyle TypeNameCheck (5 lines) + */ +@SuppressWarnings("PMD.AvoidDollarSigns") +final class EOmalloc$EOof$EOallocated$EOresizedTest { + + @Test + void throwsCorrectErrorForNewSizeAttrNaN() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new EOmallocTest.PhiWithIdDummy( + new EOmalloc$EOof$EOallocated$EOresized() + ).it(), + "new-size", + new Data.ToPhi(true) + ) + ).take(), + "put TRUE in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'new-size' attribute must be a number") + ); + } + + @Test + void throwsCorrectErrorForNewSizeAttrNotAnInt() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new EOmallocTest.PhiWithIdDummy( + new EOmalloc$EOof$EOallocated$EOresized() + ).it(), + "new-size", + new Data.ToPhi(42.42) + ) + ).take(), + "put double in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'new-size' attribute (42.42) must be an integer") + ); + } + + @Test + void throwsCorrectErrorForNewSizeAttrNotNatural() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new EOmallocTest.PhiWithIdDummy( + new EOmalloc$EOof$EOallocated$EOresized() + ).it(), + "new-size", + new Data.ToPhi(-42) + ) + ).take(), + "put negative int in natural attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'new-size' attribute (-42) must be greater or equal to zero") + ); + } + +} diff --git "a/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206Test.java" "b/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206Test.java" new file mode 100644 index 00000000000..310380b1a14 --- /dev/null +++ "b/eo-runtime/src/test/java/EOorg/EOeolang/EOmalloc$EOof$EO\317\206Test.java" @@ -0,0 +1,139 @@ +/* + * The MIT License (MIT) + * + * Copyright (c) 2016-2025 Objectionary.com + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* + * @checkstyle PackageNameCheck (4 lines) + * @checkstyle TrailingCommentCheck (3 lines) + */ +package EOorg.EOeolang; // NOPMD + +import org.eolang.AtVoid; +import org.eolang.Attr; +import org.eolang.Data; +import org.eolang.Dataized; +import org.eolang.ExAbstract; +import org.eolang.PhDefault; +import org.eolang.PhWith; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; + +// @checkstyle MissingDeprecatedCheck (10 lines) +// @checkstyle AtclauseOrderCheck (10 lines) + +/** + * Test case for {@link EOmalloc$EOof$EOφ}. + * + * @since 0.52 + * @checkstyle TypeNameCheck (5 lines) + */ +@SuppressWarnings("PMD.AvoidDollarSigns") +final class EOmalloc$EOof$EOφTest { + + @Test + void throwsCorrectErrorForSizeAttrNaN() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new EOmalloc$EOof$EOφ(), + Attr.RHO, + new PhWith( + new EOmalloc$EOof$EOφTest.SizeDummy(), + "size", + new Data.ToPhi(true) + ) + ) + ).take(), + "put TRUE in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'size' attribute must be a number") + ); + } + + @Test + void throwsCorrectErrorForSizeAttrNotAnInt() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new EOmalloc$EOof$EOφ(), + Attr.RHO, + new PhWith( + new EOmalloc$EOof$EOφTest.SizeDummy(), + "size", + new Data.ToPhi(42.42) + ) + ) + ).take(), + "put double in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'size' attribute (42.42) must be an integer") + ); + } + + @Test + void throwsCorrectErrorForSizeAttrNotNatural() { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new EOmalloc$EOof$EOφ(), + Attr.RHO, + new PhWith( + new EOmalloc$EOof$EOφTest.SizeDummy(), + "size", + new Data.ToPhi(-42) + ) + ) + ).take(), + "put negative int in natural attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'size' attribute (-42) must be greater or equal to zero") + ); + } + + /** + * Dummy with size attr. + * + * @since 0.52 + */ + private static class SizeDummy extends PhDefault { + /** + * Ctor. + */ + @SuppressWarnings("PMD.ConstructorOnlyInitializesOrCallOtherConstructors") + SizeDummy() { + this.add("size", new AtVoid("size")); + } + } + +} diff --git a/eo-runtime/src/test/java/EOorg/EOeolang/EOmallocTest.java b/eo-runtime/src/test/java/EOorg/EOeolang/EOmallocTest.java index 059b77b2d18..d5f02ddd2d4 100644 --- a/eo-runtime/src/test/java/EOorg/EOeolang/EOmallocTest.java +++ b/eo-runtime/src/test/java/EOorg/EOeolang/EOmallocTest.java @@ -39,8 +39,12 @@ import org.eolang.PhDefault; import org.eolang.PhWith; import org.eolang.Phi; +import org.hamcrest.MatcherAssert; +import org.hamcrest.Matchers; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; /** * Test case for {@link EOmalloc}. @@ -85,6 +89,139 @@ void freesMemoryIfErrorIsOccurred() { ); } + @ParameterizedTest + @ValueSource(classes = { + EOmalloc$EOof$EOallocated$EOread.class, + EOmalloc$EOof$EOallocated$EOresized.class, + EOmalloc$EOof$EOallocated$EOsize.class, + EOmalloc$EOof$EOallocated$EOwrite.class + }) + void throwsCorrectErrorForIdAttrNaN(final Class cls) { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + (Phi) cls.getDeclaredConstructor().newInstance(), + Attr.RHO, + new PhWith( + new EOmallocTest.IdDummy(), + "id", + new Data.ToPhi(true) + ) + ) + ).take(), + "put TRUE in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'id' attribute must be a number") + ); + } + + @ParameterizedTest + @ValueSource(classes = { + EOmalloc$EOof$EOallocated$EOread.class, + EOmalloc$EOof$EOallocated$EOresized.class, + EOmalloc$EOof$EOallocated$EOsize.class, + EOmalloc$EOof$EOallocated$EOwrite.class + }) + void throwsCorrectErrorForIdAttrNotAnInt(final Class cls) { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + (Phi) cls.getDeclaredConstructor().newInstance(), + Attr.RHO, + new PhWith( + new EOmallocTest.IdDummy(), + "id", + new Data.ToPhi(42.42) + ) + ) + ).take(), + "put double in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'id' attribute (42.42) must be an integer") + ); + } + + @ParameterizedTest + @ValueSource(classes = { + EOmalloc$EOof$EOallocated$EOread.class, + EOmalloc$EOof$EOallocated$EOwrite.class + }) + void throwsCorrectErrorForOffsetAttrNaN(final Class cls) { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new PhiWithIdDummy( + (Phi) cls.getDeclaredConstructor().newInstance() + ).it(), + "offset", + new Data.ToPhi(true) + ) + ).take(), + "put TRUE in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'offset' attribute must be a number") + ); + } + + @ParameterizedTest + @ValueSource(classes = { + EOmalloc$EOof$EOallocated$EOread.class, + EOmalloc$EOof$EOallocated$EOwrite.class + }) + void throwsCorrectErrorForOffsetAttrNotAnInt(final Class cls) { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new PhiWithIdDummy( + (Phi) cls.getDeclaredConstructor().newInstance() + ).it(), + "offset", + new Data.ToPhi(42.42) + ) + ).take(), + "put double in int attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'offset' attribute (42.42) must be an integer") + ); + } + + @ParameterizedTest + @ValueSource(classes = { + EOmalloc$EOof$EOallocated$EOread.class, + EOmalloc$EOof$EOallocated$EOwrite.class + }) + void throwsCorrectErrorForOffsetAttrNotNatural(final Class cls) { + MatcherAssert.assertThat( + "the message in the error is correct", + Assertions.assertThrows( + ExAbstract.class, + () -> new Dataized( + new PhWith( + new PhiWithIdDummy( + (Phi) cls.getDeclaredConstructor().newInstance() + ).it(), + "offset", + new Data.ToPhi(-42) + ) + ).take(), + "put negative int in natural attr fails with a proper message that explains what happened" + ).getMessage(), + Matchers.equalTo("the 'offset' attribute (-42) must be greater or equal to zero") + ); + } + /** * Allocated data. * @param obj Init object @@ -129,6 +266,58 @@ private static class Dummy extends PhDefault { } } + /** + * Phi with Dummy with 'id' attribute. + * + * @since 0.52 + */ + @SuppressWarnings("PMD.ShortMethodName") + static class PhiWithIdDummy { + /** + * Phi. + */ + private final Phi phi; + + /** + * Ctor. + * @param phi Phi + */ + PhiWithIdDummy(final Phi phi) { + this.phi = phi; + } + + /** + * Return it. + * @checkstyle MethodNameCheck (5 lines) + */ + public Phi it() { + return new PhWith( + this.phi, + Attr.RHO, + new PhWith( + new EOmallocTest.IdDummy(), + "id", + new Data.ToPhi(42) + ) + ); + } + } + + /** + * Dummy with id attr. + * + * @since 0.52 + */ + private static class IdDummy extends PhDefault { + /** + * Ctor. + */ + @SuppressWarnings("PMD.ConstructorOnlyInitializesOrCallOtherConstructors") + IdDummy() { + this.add("id", new AtVoid("id")); + } + } + /** * Dummy that throws an exception. * @since 0.36.0 @@ -164,4 +353,5 @@ private static class ErrorDummy extends PhDefault { ); } } + }