Merge pull request #27 from icon-project/feature-event

Feature event

Author: sink772

unittest/build.gradle

@@ -15,10 +15,13 @@ dependencies {
     implementation 'org.ow2.asm:asm:7.0'
     implementation 'org.ow2.asm:asm-commons:7.0'
     implementation 'foundation.icon:blst-java:0.3.0'
+    implementation 'foundation.icon:javaee-annotation-processor:0.9.0'
+    implementation 'com.squareup:javapoet:1.12.1'
 
     testImplementation 'foundation.icon:javaee-scorex:0.5.3'
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
+    testAnnotationProcessor project
 }
 
 test {

unittest/src/main/java/com/iconloop/score/test/Event.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2023 PARAMETA Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.iconloop.score.test;
+
+import score.Address;
+import score.impl.TypeConverter;
+
+public class Event {
+    private final Address contract;
+    private final Object[] indexed;
+    private final Object[] data;
+
+    public static final Object[] EMPTY = new Object[0];
+
+    public Event(Address contract, Object[] indexed, Object[] data) {
+        if (contract != null && !contract.isContract()) {
+            throw new IllegalArgumentException("invalid contract address");
+        }
+        if (indexed == null || indexed.length < 1 || indexed.length > 4) {
+            throw new IllegalArgumentException("invalid indexed parameter: length=" +
+                    ((indexed != null) ? indexed.length : "null"));
+        }
+        this.contract = contract;
+        this.indexed = indexed;
+        this.data = data == null ? EMPTY : data;
+        for (var obj : this.indexed) {
+            if (!TypeConverter.isValidEventValue(obj)) {
+                throw new IllegalArgumentException("invalid value type " + obj.getClass());
+            }
+        }
+        for (var obj : this.data) {
+            if (!TypeConverter.isValidEventValue(obj)) {
+                throw new IllegalArgumentException("invalid value type " + obj.getClass());
+            }
+        }
+    }
+
+    public int numberOfIndexed() {
+        return indexed.length;
+    }
+
+    public int numberOfData() {
+        return data.length;
+    }
+
+    public Address getContract() {
+        return this.contract;
+    }
+
+    public Object getIndexed(int idx) {
+        return this.indexed[idx];
+    }
+    public Object getData(int idx) {
+        return this.data[idx];
+    }
+
+    private boolean match(Event log, boolean ignoreNull) {
+        if (this == log) {
+            return true;
+        }
+
+        if (indexed.length != log.indexed.length
+                || data.length != log.data.length
+        ) {
+            return false;
+        }
+        if (contract != null) {
+            if (!contract.equals(log.contract)) {
+                return false;
+            }
+        } else {
+            if (!ignoreNull && log.contract != null) {
+                return false;
+            }
+        }
+        for (int i=0 ; i<indexed.length ; i++) {
+            var v1 = indexed[i];
+            if (v1==null && ignoreNull) continue;
+            var v2 = log.indexed[i];
+            var mo = TypeConverter.toBytes(v1);
+            var mv = TypeConverter.toBytes(v2);
+            if (!java.util.Arrays.equals(mo, mv)) {
+                return false;
+            }
+        }
+        for (int i=0 ; i<data.length ; i++) {
+            var v1 = data[i];
+            if (v1==null && ignoreNull) continue;
+            var v2 = log.data[i];
+            var mo = TypeConverter.toBytes(v1);
+            var mv = TypeConverter.toBytes(v2);
+            if (!java.util.Arrays.equals(mo, mv)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean match(Event log) {
+        return this.match(log, true);
+    }
+
+    @Override
+    public boolean equals(Object log) {
+        if (log == null || this.getClass() != log.getClass()) {
+            return false;
+        }
+        return this.match((Event)log, false);
+    }
+
+    @Override
+    public String toString() {
+        return "Event(caller="+contract
+                +",indexed="+java.util.Arrays.toString(indexed)
+                +",data="+java.util.Arrays.toString(data)+")";
+    }
+}

unittest/src/main/java/com/iconloop/score/test/GenerateTScore.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2023 PARAMETA Corp.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.iconloop.score.test;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * {@code @GenerateTScore} is used to generate a wrapper SCORE class for testing.
+ * If you deploy the generated SCORE class using the unittest framework,
+ * the following additional features are available.
+ * <ul>
+ * <li>Log a proper event on calling the method tagged with {@link score.annotation.EventLog}</li>
+ * <li>Check if a method is properly tagged with {@link score.annotation.External} and {@link score.annotation.Payable}</li>
+ * <li>Check if a parameter is properly tagged with {@link score.annotation.Optional}</li>
+ * </ul>
+ * For this, the class and its methods should be non-final in order to be extended by the generated SCORE class.
+ *
+ * <p>For example, the following is your contract implementation.
+ * <pre>
+ * public class MyContract {
+ *     public MyContract() { }
+ *
+ *     &#64;External
+ *     public void setValue(String value) {
+ *         ...
+ *     }
+ * }
+ * </pre>
+ *
+ * Then you may deploy the contract with the generated SCORE class in the unittest.
+ * Note that the default suffix for the generated class is <em>TS</em>.
+ * <pre>
+ * public class MyContractTest {
+ *     &#64;Test
+ *     &#64;GenerateTScore(MyContract.class)
+ *     public void testSetValue() {
+ *         var score = sm.deploy(MyContractTS.class);
+ *     }
+ * }
+ * </pre>
+ *
+ * Of course, you may use the class as is, without any additional features.
+ */
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.SOURCE)
+@Repeatable(GenerateTScores.class)
+public @interface GenerateTScore {
+    Class<?> value() default GenerateTScore.class;
+    String suffix() default "TS";
+}