diff --git a/README.md b/README.md index 87ffcbb..1a6a1a9 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,4 @@ +[![Review Assignment Due Date](https://classroom.github.com/assets/deadline-readme-button-22041afd0340ce965d47ae6ef1cefeee28c7c493a6346c4f15d667ab976d596c.svg)](https://classroom.github.com/a/4ISSpVK4) **Java reflection** Ваша задача --- написать генератор экземпляров произвольных классов. diff --git a/build.gradle.kts b/build.gradle.kts index b4738ae..a04c51e 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -1,5 +1,6 @@ plugins { id("java") + id("net.bytebuddy.byte-buddy-gradle-plugin") version "1.17.8" } group = "org.example" @@ -12,6 +13,7 @@ repositories { dependencies { testImplementation(platform("org.junit:junit-bom:5.10.0")) testImplementation("org.junit.jupiter:junit-jupiter") + implementation("net.bytebuddy:byte-buddy:1.15.9") testRuntimeOnly("org.junit.platform:junit-platform-launcher") } diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index 47679a9..5320ffb 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -1,15 +1,28 @@ package org.example; - -import org.example.classes.Example; import org.example.generator.Generator; +import java.lang.reflect.Field; + public class GenerateExample { public static void main(String[] args) { var gen = new Generator(); try { - Object generated = gen.generateValueOfType(Example.class); - System.out.println(generated); + int depth = 0; + Object generated = gen.generateValueOfType(org.example.classes.Cart.class, depth); + if (generated == null) { + System.out.println("Generated object is null"); + return; + } + System.out.println("Generated " + generated); + System.out.println("With attributes:"); + Field[] fields = generated.getClass().getDeclaredFields(); + for (Field field : fields) { + field.setAccessible(true); + System.out.println( + "Field " + field.getName() + " with type:" + field.getType() + " and value:" + field.get(generated) + ); + } } catch (Throwable e) { throw new RuntimeException(e); } diff --git a/src/main/java/org/example/annotation/Generatable.java b/src/main/java/org/example/annotation/Generatable.java new file mode 100644 index 0000000..a057fdb --- /dev/null +++ b/src/main/java/org/example/annotation/Generatable.java @@ -0,0 +1,11 @@ +package org.example.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.TYPE) +public @interface Generatable { +} \ No newline at end of file diff --git a/src/main/java/org/example/classes/BinaryTreeNode.java b/src/main/java/org/example/classes/BinaryTreeNode.java index 046ff56..aa69ea8 100644 --- a/src/main/java/org/example/classes/BinaryTreeNode.java +++ b/src/main/java/org/example/classes/BinaryTreeNode.java @@ -1,5 +1,9 @@ package org.example.classes; + +import org.example.annotation.Generatable; + +@Generatable public class BinaryTreeNode { private Integer data; private BinaryTreeNode left; diff --git a/src/main/java/org/example/classes/Cart.java b/src/main/java/org/example/classes/Cart.java index 965237d..813b02e 100644 --- a/src/main/java/org/example/classes/Cart.java +++ b/src/main/java/org/example/classes/Cart.java @@ -1,21 +1,22 @@ package org.example.classes; +import org.example.annotation.Generatable; + import java.util.List; +@Generatable public class Cart { - private List items; + private List items; - public Cart(List items) { + public Cart(List items) { this.items = items; } - public List getItems() { + public List getItems() { return items; } - public void setItems(List items) { + public void setItems(List items) { this.items = items; } - - // Конструктор, методы добавления и удаления товаров, геттеры и другие методы } \ No newline at end of file diff --git a/src/main/java/org/example/classes/Example.java b/src/main/java/org/example/classes/Example.java index eac9463..554ee2b 100644 --- a/src/main/java/org/example/classes/Example.java +++ b/src/main/java/org/example/classes/Example.java @@ -1,5 +1,8 @@ package org.example.classes; +import org.example.annotation.Generatable; + +@Generatable public class Example { int i; diff --git a/src/main/java/org/example/classes/Product.java b/src/main/java/org/example/classes/Product.java index e7dcc89..aaada2e 100644 --- a/src/main/java/org/example/classes/Product.java +++ b/src/main/java/org/example/classes/Product.java @@ -1,5 +1,8 @@ package org.example.classes; +import org.example.annotation.Generatable; + +@Generatable public class Product { private String name; private double price; diff --git a/src/main/java/org/example/classes/Rectangle.java b/src/main/java/org/example/classes/Rectangle.java index 90b0886..e7186a2 100644 --- a/src/main/java/org/example/classes/Rectangle.java +++ b/src/main/java/org/example/classes/Rectangle.java @@ -1,5 +1,8 @@ package org.example.classes; +import org.example.annotation.Generatable; + +@Generatable public class Rectangle implements Shape { private double length; private double width; diff --git a/src/main/java/org/example/classes/Triangle.java b/src/main/java/org/example/classes/Triangle.java index 011e96f..a6fc58a 100644 --- a/src/main/java/org/example/classes/Triangle.java +++ b/src/main/java/org/example/classes/Triangle.java @@ -1,5 +1,8 @@ package org.example.classes; +import org.example.annotation.Generatable; + +@Generatable public class Triangle implements Shape { private double sideA; private double sideB; diff --git a/src/main/java/org/example/generator/AtomicGenerator.java b/src/main/java/org/example/generator/AtomicGenerator.java new file mode 100644 index 0000000..3a6cc0f --- /dev/null +++ b/src/main/java/org/example/generator/AtomicGenerator.java @@ -0,0 +1,34 @@ +package main.java.org.example.generator; + +import java.io.Serializable; +import java.util.HashMap; +import java.util.Map; +import java.util.Random; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Supplier; + +public class AtomicGenerator { + private final Random random = new Random(); + private final Map, Supplier> generators; + + public AtomicGenerator() + { + generators = new HashMap<>(); + generators.put(AtomicInteger.class, () -> new AtomicInteger(random.nextInt(Integer.MAX_VALUE))); + generators.put(AtomicLong.class, () -> new AtomicLong(random.nextInt(Integer.MAX_VALUE))); + generators.put(AtomicBoolean.class, () -> new AtomicBoolean(random.nextBoolean())); + generators.put(AtomicReference.class, () -> new AtomicReference<>(random.nextInt())); + } + + public Object generate(Class clazz) + { + Supplier supplier = generators.get(clazz); + if (supplier == null) { + return null; + } + return supplier.get(); + } +} diff --git a/src/main/java/org/example/generator/FromInterfaceGenerator.java b/src/main/java/org/example/generator/FromInterfaceGenerator.java new file mode 100644 index 0000000..e35493d --- /dev/null +++ b/src/main/java/org/example/generator/FromInterfaceGenerator.java @@ -0,0 +1,29 @@ +package org.example.generator; + +import net.bytebuddy.ByteBuddy; + +import java.lang.reflect.InvocationTargetException; + +public class FromInterfaceGenerator { + + public Object generate(Class clazz) throws + ClassNotFoundException, + InvocationTargetException, + IllegalAccessException, + NoSuchMethodException, + InstantiationException + { + String className = clazz.getName(); + Class interfaceClass = Class.forName(className); + Class dynamicType = new ByteBuddy() + .subclass(Object.class) + .implement(interfaceClass) + .make() + .load(clazz.getClassLoader()) + .getLoaded(); + Object instance = dynamicType.getDeclaredConstructor().newInstance(); + boolean implementsInterface = clazz.isAssignableFrom(instance.getClass()); + System.out.println("Implements interface? " + implementsInterface); + return instance; + } +} diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 9d86bfb..42e7fc1 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -1,18 +1,105 @@ package org.example.generator; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; -import java.util.Random; +import main.java.org.example.generator.*; +import org.example.annotation.Generatable; + +import java.lang.reflect.*; +import java.util.*; +import java.util.concurrent.*; + public class Generator { - public Object generateValueOfType(Class clazz) throws InvocationTargetException, InstantiationException, IllegalAccessException { - Constructor[] constructors = clazz.getDeclaredConstructors(); + private final Random random = new Random(); + private final PrimitiveGenerator primitiveGenerator = new PrimitiveGenerator(); + private final AtomicGenerator atomicGenerator = new AtomicGenerator(); + private final QueueGenerator queueGenerator = new QueueGenerator(); + private final SequenceGenerator sequenceGenerator = new SequenceGenerator(); + private final MapGenerator mapGenerator = new MapGenerator(); + private final FromInterfaceGenerator fromInterfaceGenerator = new FromInterfaceGenerator(); + private static final int MAX_DEPTH = 10; + + public Object generateValueOfType(Type type, int depth) throws + InvocationTargetException, + InstantiationException, + IllegalAccessException, + NoSuchMethodException, + ClassNotFoundException + { + if (depth > MAX_DEPTH) { + return null; + } + if (type instanceof Class clazz) { + Object primitiveValue = primitiveGenerator.generate(clazz); + if (primitiveValue != null) return primitiveValue; + + Object atomicValue = atomicGenerator.generate(clazz); + if (atomicValue != null) return atomicValue; + + Object queueValue = queueGenerator.generate(clazz); + if (queueValue != null) return queueValue; - int randomConstructorIndex = new Random().nextInt(constructors.length); - Constructor randomConstructor = constructors[randomConstructorIndex]; - return randomConstructor.newInstance(111); + if (Collection.class.isAssignableFrom(clazz)) { + return sequenceGenerator.generate(clazz); + } + if (Map.class.isAssignableFrom(clazz)) { + return mapGenerator.generate(clazz); + } + if (clazz.isEnum()) { + Object[] arr = clazz.getEnumConstants(); + return arr[random.nextInt(arr.length)]; + } + if (clazz.isInterface()) { + return fromInterfaceGenerator.generate(clazz); + } + return generateType(clazz, depth + 1); + } + + if (type instanceof ParameterizedType pType) { + Type raw = pType.getRawType(); + if (!(raw instanceof Class rawClass)) { + throw new IllegalArgumentException("Unsupported raw type: " + raw); + } + if (Collection.class.isAssignableFrom(rawClass)) { + Collection collection; + if (rawClass.isInterface()) { + collection = new ArrayList<>(); + } else { + collection = (Collection) rawClass.getDeclaredConstructor().newInstance(); + } + Type elementType = pType.getActualTypeArguments()[0]; + for (int i = 0; i < 3; i++) { + Object element = generateValueOfType(elementType, depth + 1); + collection.add(element); + } + return collection; + } + return generateType((Class) rawClass, depth + 1); + } + throw new IllegalArgumentException("Unsupported type: " + type); } + private Object generateType(Class clazz, int depth) throws + InvocationTargetException, + InstantiationException, + IllegalAccessException, + NoSuchMethodException, + ClassNotFoundException + { + Constructor constructor = clazz.getDeclaredConstructors()[0]; + + if (!clazz.isAnnotationPresent(Generatable.class)) { + throw new IllegalArgumentException("Class " + clazz.getName() + " has no Generatable annotation"); + } + + Type[] paramTypes = constructor.getGenericParameterTypes(); + Object[] params = new Object[paramTypes.length]; + for (int i = 0; i < paramTypes.length; i++) { + params[i] = generateValueOfType(paramTypes[i], depth + 1); + } + + constructor.setAccessible(true); + return constructor.newInstance(params); + } } diff --git a/src/main/java/org/example/generator/MapGenerator.java b/src/main/java/org/example/generator/MapGenerator.java new file mode 100644 index 0000000..259d81c --- /dev/null +++ b/src/main/java/org/example/generator/MapGenerator.java @@ -0,0 +1,61 @@ +package main.java.org.example.generator; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.Supplier; + +public class MapGenerator { + private final Random random = new Random(); + private final Map, Supplier> generators = new HashMap<>(); + + public MapGenerator() + { + generators.put(HashMap.class, () -> { + HashMap map = new HashMap<>(); + fillMap(map); + return map; + }); + generators.put(LinkedHashMap.class, () -> { + LinkedHashMap map = new LinkedHashMap<>(); + fillMap(map); + return map; + }); + generators.put(TreeMap.class, () -> { + TreeMap map = new TreeMap<>(); + fillMap(map); + return map; + }); + generators.put(ConcurrentHashMap.class, () -> { + ConcurrentHashMap map = new ConcurrentHashMap<>(); + fillMap(map); + return map; + }); + generators.put(WeakHashMap.class, () -> { + WeakHashMap map = new WeakHashMap<>(); + fillMap(map); + return map; + }); + generators.put(IdentityHashMap.class, () -> { + IdentityHashMap map = new IdentityHashMap<>(); + fillMap(map); + return map; + }); + } + + private void fillMap(Map map) + { + int randomSize = random.nextInt(100); + for (int i = 0; i < randomSize; i++) { + map.put(String.valueOf(i), new Object()); + } + } + + public Map generate(Class clazz) + { + Supplier supplier = generators.get(clazz); + if (supplier == null) { + return null; + } + return (Map) supplier.get(); + } +} diff --git a/src/main/java/org/example/generator/PrimitiveGenerator.java b/src/main/java/org/example/generator/PrimitiveGenerator.java new file mode 100644 index 0000000..86ed3da --- /dev/null +++ b/src/main/java/org/example/generator/PrimitiveGenerator.java @@ -0,0 +1,44 @@ +package main.java.org.example.generator; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.*; +import java.util.function.Supplier; + +public class PrimitiveGenerator { + private final Random random = new Random(); + private final Map, Supplier> generators = new HashMap<>(); + + public PrimitiveGenerator() + { + generators.put(int.class, () -> random.nextInt(1000)); + generators.put(Integer.class, () -> random.nextInt(1000)); + generators.put(double.class, () -> random.nextDouble()); + generators.put(Double.class, () -> random.nextDouble()); + generators.put(String.class, () -> "some_string_" + random.nextInt(1000)); + generators.put(boolean.class, () -> random.nextBoolean()); + generators.put(Boolean.class, () -> random.nextBoolean()); + generators.put(float.class, () -> random.nextFloat()); + generators.put(Float.class, () -> random.nextFloat()); + generators.put(long.class, () -> random.nextLong()); + generators.put(Long.class, () -> random.nextLong()); + generators.put(BigDecimal.class, () -> new BigDecimal(random.nextDouble())); + generators.put(BigInteger.class, () -> new BigInteger(String.valueOf(random.nextLong()))); + generators.put(char.class, () -> (char) ('a' + random.nextInt(26))); + generators.put(Character.class, () -> (char) ('a' + random.nextInt(26))); + generators.put(short.class, () -> (short) random.nextInt(Short.MAX_VALUE)); + generators.put(Short.class, () -> (short) random.nextInt(Short.MAX_VALUE)); + generators.put(byte.class, () -> (byte) random.nextInt(Byte.MAX_VALUE)); + generators.put(Byte.class, () -> (byte) random.nextInt(Byte.MAX_VALUE)); + generators.put(Date.class, Date::new); + } + + public Object generate(Class clazz) + { + Supplier supplier = generators.get(clazz); + if (supplier != null) { + return supplier.get(); + } + return null; + } +} diff --git a/src/main/java/org/example/generator/QueueGenerator.java b/src/main/java/org/example/generator/QueueGenerator.java new file mode 100644 index 0000000..1124730 --- /dev/null +++ b/src/main/java/org/example/generator/QueueGenerator.java @@ -0,0 +1,49 @@ +package main.java.org.example.generator; + +import java.util.*; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.function.Supplier; + +public class QueueGenerator { + + private final Random random = new Random(); + private final Map, Supplier> queueGenerator = new HashMap<>(); + + public QueueGenerator() + { + queueGenerator.put(ArrayBlockingQueue.class, () -> { + Queue q = new ArrayBlockingQueue<>(100); + fillQueue(q); + return q; + }); + queueGenerator.put(LinkedBlockingQueue.class, () -> { + Queue q = new LinkedBlockingQueue<>(100); + fillQueue(q); + return q; + }); + queueGenerator.put(ConcurrentLinkedQueue.class, () -> { + Queue q = new ConcurrentLinkedQueue<>(); + fillQueue(q); + return q; + }); + } + + private void fillQueue(Queue queue) + { + int size = random.nextInt(100); + for (int i = 0; i < size; i++) { + queue.add(new Object()); + } + } + + public Object generate(Class clazz) + { + Supplier supplier = queueGenerator.get(clazz); + if (supplier != null) { + return supplier.get(); + } + return null; + } +} diff --git a/src/main/java/org/example/generator/SequenceGenerator.java b/src/main/java/org/example/generator/SequenceGenerator.java new file mode 100644 index 0000000..f59dcf0 --- /dev/null +++ b/src/main/java/org/example/generator/SequenceGenerator.java @@ -0,0 +1,46 @@ +package main.java.org.example.generator; + +import java.lang.reflect.Array; +import java.util.*; +import java.util.function.Supplier; + +public class SequenceGenerator { + private final Random random = new Random(); + private final Map, Supplier> sequnceGenerator = new HashMap<>(); + + public SequenceGenerator() + { + sequnceGenerator.put(List.class, this::generateList); + sequnceGenerator.put(ArrayList.class, this::generateList); + sequnceGenerator.put(LinkedList.class, this::generateArray); + } + + public Object generate(Class clazz) + { + Supplier supplier = sequnceGenerator.get(clazz); + if (supplier != null) { + return supplier.get(); + } + return null; + } + + private List generateList() + { + List list = new ArrayList<>(); + int num = random.nextInt(1000); + for (int i = 0; i < num; i++) { + list.add(new Object()); + } + return list; + } + + private Object generateArray() + { + int randomIndex = random.nextInt(100); + Object arr = Array.newInstance(Object.class, randomIndex); + for (int i = 0; i < randomIndex; i++) { + Array.set(arr, i, new Object()); + } + return arr; + } +} diff --git a/src/test/java/org/example/Generator/AtomicGeneratorTest.java b/src/test/java/org/example/Generator/AtomicGeneratorTest.java new file mode 100644 index 0000000..4f42c5c --- /dev/null +++ b/src/test/java/org/example/Generator/AtomicGeneratorTest.java @@ -0,0 +1,52 @@ +package org.example.Generator; + +import java.io.Serializable; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import main.java.org.example.generator.AtomicGenerator; +import org.junit.jupiter.api.Test; + +public class AtomicGeneratorTest { + + private AtomicGenerator atomicGenerator; + + @BeforeEach + void setUp() { atomicGenerator = new AtomicGenerator();} + + @Test + public void test_generates_atomic_int() + { + Serializable atomicInt = (Serializable) atomicGenerator.generate(AtomicInteger.class); + Assertions.assertNotNull(atomicInt); + Assertions.assertEquals(AtomicInteger.class, atomicInt.getClass()); + } + + @Test + public void test_generates_atomic_long() + { + Serializable atomicLong = (Serializable) atomicGenerator.generate(AtomicLong.class); + Assertions.assertNotNull(atomicLong); + Assertions.assertEquals(AtomicLong.class, atomicLong.getClass()); + } + + @Test + public void test_generates_atomic_bool() + { + Serializable atomicBoolean = (Serializable) atomicGenerator.generate(AtomicBoolean.class); + Assertions.assertNotNull(atomicBoolean); + Assertions.assertEquals(AtomicBoolean.class, atomicBoolean.getClass()); + } + + @Test + public void test_generates_atomic_reference() + { + Serializable atomicReference = (Serializable) atomicGenerator.generate(AtomicReference.class); + Assertions.assertNotNull(atomicReference); + Assertions.assertEquals(AtomicReference.class, atomicReference.getClass()); + } +} diff --git a/src/test/java/org/example/Generator/GeneratorTest.java b/src/test/java/org/example/Generator/GeneratorTest.java new file mode 100644 index 0000000..838ae44 --- /dev/null +++ b/src/test/java/org/example/Generator/GeneratorTest.java @@ -0,0 +1,40 @@ +package org.example.Generator; + +import org.example.generator.Generator; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.InvocationTargetException; +import java.util.Arrays; + + +public class GeneratorTest { + private Generator generator; + private RandomClassGenerator randomClassGenerator; + + @BeforeEach + void setUp() + { + generator = new Generator(); + randomClassGenerator = new RandomClassGenerator(); + } + + @Test + public void generate_random_object() throws + InvocationTargetException, + InstantiationException, + IllegalAccessException + { + for (int i = 0; i < 100; i++) + { + Class randomClass = randomClassGenerator.getRandomClass(); + Object newRandomClass = generator.generateValueOfType(randomClass); + String randomClassFields = Arrays.toString(randomClass.getDeclaredFields()); + String randomNewClassFields = Arrays.toString(randomClass.getDeclaredFields()); + Assertions.assertNotNull(newRandomClass); + Assertions.assertEquals(newRandomClass.getClass(), randomClass); + Assertions.assertEquals(randomClassFields, randomNewClassFields); + } + } +} diff --git a/src/test/java/org/example/Generator/MapGeneratorTest.java b/src/test/java/org/example/Generator/MapGeneratorTest.java new file mode 100644 index 0000000..3867ee4 --- /dev/null +++ b/src/test/java/org/example/Generator/MapGeneratorTest.java @@ -0,0 +1,74 @@ +package org.example.Generator; + +import main.java.org.example.generator.MapGenerator; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + + +public class MapGeneratorTest { + + private MapGenerator mapGenerator; + + @BeforeEach + void setUp() { + mapGenerator = new MapGenerator(); + } + + @Test + void test_generate_map() + { + Map map = mapGenerator.generate(HashMap.class); + Assertions.assertNotNull(map); + Assertions.assertFalse(map.isEmpty()); + Assertions.assertTrue(map instanceof HashMap); + } + + @Test + void test_generate_concurrent_map() + { + Map map = mapGenerator.generate(ConcurrentHashMap.class); + Assertions.assertNotNull(map); + Assertions.assertFalse(map.isEmpty()); + Assertions.assertTrue(map instanceof ConcurrentHashMap); + } + + @Test + void test_generate_treemap() + { + Map map = mapGenerator.generate(TreeMap.class); + Assertions.assertNotNull(map); + Assertions.assertFalse(map.isEmpty()); + Assertions.assertTrue(map instanceof TreeMap); + } + + @Test + void test_generate_linked_hashmap() + { + Map map = mapGenerator.generate(LinkedHashMap.class); + Assertions.assertNotNull(map); + Assertions.assertFalse(map.isEmpty()); + Assertions.assertTrue(map instanceof LinkedHashMap); + } + + @Test + void test_generate_weak_hashmap() + { + Map map = mapGenerator.generate(WeakHashMap.class); + Assertions.assertNotNull(map); + Assertions.assertFalse(map.isEmpty()); + Assertions.assertTrue(map instanceof WeakHashMap); + } + + @Test + void test_generate_identity_map() + { + Map map = mapGenerator.generate(IdentityHashMap.class); + Assertions.assertNotNull(map); + Assertions.assertFalse(map.isEmpty()); + Assertions.assertTrue(map instanceof IdentityHashMap); + } +} diff --git a/src/test/java/org/example/Generator/PrimitiveGeneratorTest.java b/src/test/java/org/example/Generator/PrimitiveGeneratorTest.java new file mode 100644 index 0000000..6a9107a --- /dev/null +++ b/src/test/java/org/example/Generator/PrimitiveGeneratorTest.java @@ -0,0 +1,183 @@ +package org.example.Generator; + +import main.java.org.example.generator.PrimitiveGenerator; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Date; + +public class PrimitiveGeneratorTest { + + private PrimitiveGenerator primitiveGenerator; + + @BeforeEach + public void setup() + { + primitiveGenerator = new PrimitiveGenerator(); + } + + @Test + public void test_generate_int() + { + Object someInt = primitiveGenerator.generate(int.class); + Assertions.assertNotNull(someInt); + Assertions.assertEquals(Integer.class, someInt.getClass()); + } + + @Test + public void test_generate_Integer() + { + Object someInt = primitiveGenerator.generate(Integer.class); + Assertions.assertNotNull(someInt); + Assertions.assertEquals(Integer.class, someInt.getClass()); + } + + @Test + public void test_generate_string() + { + Object someString = primitiveGenerator.generate(String.class); + Assertions.assertNotNull(someString); + Assertions.assertEquals(String.class, someString.getClass()); + } + + @Test + public void test_generate_long() + { + Object someLong = primitiveGenerator.generate(long.class); + Assertions.assertNotNull(someLong); + Assertions.assertEquals(Long.class, someLong.getClass()); + } + + @Test + public void test_generate_Long() + { + Object someLong = primitiveGenerator.generate(Long.class); + Assertions.assertNotNull(someLong); + Assertions.assertEquals(Long.class, someLong.getClass()); + } + + @Test + public void test_generate_boolean() + { + Object someBoolean = primitiveGenerator.generate(boolean.class); + Assertions.assertNotNull(someBoolean); + Assertions.assertEquals(Boolean.class, someBoolean.getClass()); + } + + @Test + public void test_generate_Boolean() + { + Object someBoolean = primitiveGenerator.generate(Boolean.class); + Assertions.assertNotNull(someBoolean); + Assertions.assertEquals(Boolean.class, someBoolean.getClass()); + } + + @Test + public void test_generate_double() + { + Object someDouble = primitiveGenerator.generate(double.class); + Assertions.assertNotNull(someDouble); + Assertions.assertEquals(Double.class, someDouble.getClass()); + } + + @Test + public void test_generate_Double() + { + Object someDouble = primitiveGenerator.generate(Double.class); + Assertions.assertNotNull(someDouble); + Assertions.assertEquals(Double.class, someDouble.getClass()); + } + + @Test + public void test_generate_float() + { + Object someFloat = primitiveGenerator.generate(float.class); + Assertions.assertNotNull(someFloat); + Assertions.assertEquals(Float.class, someFloat.getClass()); + } + + @Test + public void test_generate_Float() + { + Object someFloat = primitiveGenerator.generate(Float.class); + Assertions.assertNotNull(someFloat); + Assertions.assertEquals(Float.class, someFloat.getClass()); + } + + @Test + public void test_generate_short() + { + Object someShort = primitiveGenerator.generate(short.class); + Assertions.assertNotNull(someShort); + Assertions.assertEquals(Short.class, someShort.getClass()); + } + + @Test + public void test_generate_Short() + { + Object someShort = primitiveGenerator.generate(Short.class); + Assertions.assertNotNull(someShort); + Assertions.assertEquals(Short.class, someShort.getClass()); + } + + @Test + public void test_generate_char() + { + Object someChar = primitiveGenerator.generate(char.class); + Assertions.assertNotNull(someChar); + Assertions.assertEquals(Character.class, someChar.getClass()); + } + + @Test + public void test_generate_Character() + { + Object someChar = primitiveGenerator.generate(Character.class); + Assertions.assertNotNull(someChar); + Assertions.assertEquals(Character.class, someChar.getClass()); + } + + @Test + public void test_generate_byte() + { + Object someByte = primitiveGenerator.generate(byte.class); + Assertions.assertNotNull(someByte); + Assertions.assertEquals(Byte.class, someByte.getClass()); + } + + @Test + public void test_generate_Byte() + { + Object someByte = primitiveGenerator.generate(byte.class); + Assertions.assertNotNull(someByte); + Assertions.assertEquals(Byte.class, someByte.getClass()); + } + + @Test + public void test_generate_BigInter() + { + Object someBigInteger = primitiveGenerator.generate(BigInteger.class); + Assertions.assertNotNull(someBigInteger); + Assertions.assertEquals(BigInteger.class, someBigInteger.getClass()); + } + + @Test + public void test_generate_BigDecimal() + { + Object someBigDecimal = primitiveGenerator.generate(BigDecimal.class); + Assertions.assertNotNull(someBigDecimal); + Assertions.assertEquals(BigDecimal.class, someBigDecimal.getClass()); + } + + @Test + public void test_generate_Date() + { + Object someDate = primitiveGenerator.generate(Date.class); + Assertions.assertNotNull(someDate); + Assertions.assertEquals(Date.class, someDate.getClass()); + } +} + diff --git a/src/test/java/org/example/Generator/QueueGeneratorTest.java b/src/test/java/org/example/Generator/QueueGeneratorTest.java new file mode 100644 index 0000000..07c0803 --- /dev/null +++ b/src/test/java/org/example/Generator/QueueGeneratorTest.java @@ -0,0 +1,43 @@ +package org.example.Generator; + +import main.java.org.example.generator.QueueGenerator; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.LinkedBlockingQueue; + +public class QueueGeneratorTest { + private QueueGenerator queueGenerator; + + @BeforeEach + public void setUp() { + queueGenerator = new QueueGenerator(); + } + + @Test + public void test_generate_array_blocking_queue() + { + Object queue = queueGenerator.generate(ArrayBlockingQueue.class); + Assertions.assertNotNull(queue); + Assertions.assertTrue(queue instanceof ArrayBlockingQueue); + } + + @Test + public void test_generate_linked_blocking_queue() + { + Object queue = queueGenerator.generate(LinkedBlockingQueue.class); + Assertions.assertNotNull(queue); + Assertions.assertTrue(queue instanceof LinkedBlockingQueue); + } + + @Test + public void test_generate_concurrent_blocking_queue() + { + Object queue = queueGenerator.generate(ConcurrentLinkedQueue.class); + Assertions.assertNotNull(queue); + Assertions.assertTrue(queue instanceof ConcurrentLinkedQueue); + } +} diff --git a/src/test/java/org/example/Generator/RandomClassGenerator.java b/src/test/java/org/example/Generator/RandomClassGenerator.java new file mode 100644 index 0000000..ac40667 --- /dev/null +++ b/src/test/java/org/example/Generator/RandomClassGenerator.java @@ -0,0 +1,28 @@ +package org.example.Generator; + +import net.bytebuddy.ByteBuddy; +import net.bytebuddy.implementation.FixedValue; +import net.bytebuddy.matcher.ElementMatchers; + +import java.lang.reflect.Modifier; +import java.util.Random; + +public class RandomClassGenerator { + private final Random random = new Random(); + + public Class getRandomClass() { + String randomClassName = "org.example.SomeRandomClass_" + random.nextInt(100000); + Class dynamicClass = new ByteBuddy() + .subclass(Object.class) + .name(randomClassName) + .defineField("someString", String.class, Modifier.PUBLIC) + .defineField("someInt", int.class, Modifier.PUBLIC) + .defineField("someBoolean", Boolean.class, Modifier.PUBLIC) + .method(ElementMatchers.named("toString")) + .intercept(FixedValue.value("Hello World!")) + .make() + .load(getClass().getClassLoader()) + .getLoaded(); + return dynamicClass; + } +} diff --git a/src/test/java/org/example/Generator/SequenceGeneratorTest.java b/src/test/java/org/example/Generator/SequenceGeneratorTest.java new file mode 100644 index 0000000..39787db --- /dev/null +++ b/src/test/java/org/example/Generator/SequenceGeneratorTest.java @@ -0,0 +1,55 @@ +package org.example.Generator; + +import main.java.org.example.generator.SequenceGenerator; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Array; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; + + +public class SequenceGeneratorTest { + private SequenceGenerator sequenceGenerator; + + @BeforeEach + public void setUp() { + sequenceGenerator = new SequenceGenerator(); + } + + @Test + public void test_generate_list() + { + Object someArray = sequenceGenerator.generate(List.class); + Assertions.assertNotNull(someArray); + Assertions.assertNotNull(someArray.getClass()); + Assertions.assertTrue(someArray instanceof ArrayList); + } + + @Test + public void test_generate_arraylist() + { + Object someArray = sequenceGenerator.generate(ArrayList.class); + Assertions.assertNotNull(someArray); + Assertions.assertNotNull(someArray.getClass()); + Assertions.assertTrue(someArray instanceof ArrayList); + } + + @Test + public void test_generate_linkedlist() + { + Object someLinkedList = sequenceGenerator.generate(LinkedList.class); + Assertions.assertNotNull(someLinkedList); + Assertions.assertNotNull(someLinkedList.getClass()); + Assertions.assertTrue(someLinkedList.getClass().isArray()); + } + + @Test + public void test_generate_array_is_null() + { + Object someLinkedList = sequenceGenerator.generate(Array.class); + Assertions.assertNull(someLinkedList); + } +}