From fc5752519a7429f91b8dc0858077049bcd23e186 Mon Sep 17 00:00:00 2001 From: "github-classroom[bot]" <66690702+github-classroom[bot]@users.noreply.github.com> Date: Wed, 1 Oct 2025 16:49:47 +0000 Subject: [PATCH 01/21] add deadline --- README.md | 1 + 1 file changed, 1 insertion(+) 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** Ваша задача --- написать генератор экземпляров произвольных классов. From d52b24319667fd74f2e10bec50b3914c52c89648 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Mon, 13 Oct 2025 23:32:18 +0300 Subject: [PATCH 02/21] =?UTF-8?q?=D0=BF=D0=B5=D1=80=D0=B2=D1=8B=D0=B9=20?= =?UTF-8?q?=D0=BD=D0=B0=D0=B1=D1=80=D0=BE=D1=81=D0=BE=D0=BA=20=D0=B3=D0=B5?= =?UTF-8?q?=D0=BD=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/org/example/GenerateExample.java | 20 ++- .../java/org/example/generator/Generator.java | 117 ++++++++++++++++-- 2 files changed, 124 insertions(+), 13 deletions(-) diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index 47679a9..94e27b3 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -1,15 +1,27 @@ 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); + Object generated = gen.generateValueOfType(org.example.classes.Cart.class); + 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() + " " + field.get(generated) + ); + } } catch (Throwable e) { throw new RuntimeException(e); } diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 9d86bfb..b5be804 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -1,18 +1,117 @@ package org.example.generator; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; -import java.util.Random; +import java.lang.reflect.*; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.*; +import java.util.concurrent.*; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; +import java.util.concurrent.atomic.AtomicReference; public class Generator { - public Object generateValueOfType(Class clazz) throws InvocationTargetException, InstantiationException, IllegalAccessException { - Constructor[] constructors = clazz.getDeclaredConstructors(); + private final Random random = new Random(); + + public Object generateValueOfType(Class clazz) throws + InvocationTargetException, + InstantiationException, + IllegalAccessException + { + // Интерфейсе или абстрактные классы скипаем + if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) { + return null; + } + // Для интов генерируем рандомный инт + if (clazz.equals(int.class) || clazz.equals(Integer.class)) {return random.nextInt(1000);} + // Для даблов генерируем рандомный дабл + if (clazz.equals(double.class) || clazz.equals(Double.class)) {return random.nextDouble();} + // Если строка генерируем строку с префиксом в виде рандомного числа + if (clazz.equals(String.class)) {return "some_string_"+random.nextInt(1000);} + // Если буль - рандомный буль + if (clazz.equals(boolean.class) || clazz.equals(Boolean.class)) {return random.nextBoolean();} + // Если плавающая точка - рандомную плавающую точка + if (clazz.equals(float.class) || clazz.equals(Float.class)) {return random.nextFloat();} + // Если лонг - генерируем рандомный лонг + if (clazz.equals(long.class) || clazz.equals(Long.class)) {return random.nextLong();} + // Если большое число - генерируем рандомное большое число + if (clazz.equals(BigDecimal.class)) {return new BigDecimal(random.nextDouble());} + // Если большой инт - генерируем большой инт + if (clazz.equals(BigInteger.class)) {return new BigInteger(String.valueOf(random.nextLong()));} + // Если символ - рандомный символ + if (clazz.equals(char.class) || clazz.equals(Character.class)) {return (char) ('a' + random.nextInt(26));} + // Если шорт - генерируем рандомный шорт + if (clazz.equals(short.class) || clazz.equals(Short.class)) {return (short) random.nextInt(Short.MAX_VALUE);} + // Если байт - генерируем рандомный байт + if (clazz.equals(byte.class) || clazz.equals(Byte.class)) {return (byte) random.nextInt(Byte.MAX_VALUE);} + // Если дата - генерим текущую дату + if (clazz.equals(Date.class)) {return new Date();} + + // Обработка атомиков + if (AtomicInteger.class.equals(clazz)) {return new AtomicInteger(random.nextInt(Integer.MAX_VALUE));} + if (AtomicLong.class.equals(clazz)) {return new AtomicLong(random.nextInt(Integer.MAX_VALUE));} + if (AtomicBoolean.class.equals(clazz)) {return new AtomicBoolean(random.nextBoolean());} + if (AtomicReference.class.equals(clazz)) {return new AtomicReference<>(random.nextLong());} - int randomConstructorIndex = new Random().nextInt(constructors.length); - Constructor randomConstructor = constructors[randomConstructorIndex]; - return randomConstructor.newInstance(111); - } + // Если последовательнсть то генерируем с рандомным количеством элементов + if (clazz.isArray()) { + int randomIndex = random.nextInt(100); + Object arr = Array.newInstance(clazz.getComponentType(), randomIndex); + for (int i = 0; i < randomIndex; i++) { + Array.set(arr, i, generateValueOfType(clazz.getComponentType())); + } + return arr; + } + // Если мапа - генерируем либо обычную мапу, либо ее конкурентную версию + if (Map.class.isAssignableFrom(clazz)) { + Map map; + if (ConcurrentHashMap.class.isAssignableFrom(clazz)) { + map = new ConcurrentHashMap<>(); + } else { + map = new HashMap<>(); + } + return map; + } + // Если обьект - очередь, начинаем перебор по очередям + if (Queue.class.isAssignableFrom(clazz)) { + Queue queue; + // Блокирующие очереди + if (BlockingQueue.class.isAssignableFrom(clazz)) { + if (ArrayBlockingQueue.class.isAssignableFrom(clazz)) { + queue = new ArrayBlockingQueue(10); + } else if (LinkedBlockingQueue.class.isAssignableFrom(clazz)) { + queue = new LinkedBlockingQueue(10); + } + // Конкурентная очередь + } else if (ConcurrentLinkedQueue.class.isAssignableFrom(clazz)) { + queue = new ConcurrentLinkedQueue(); + } else { + // Обычная очередь + queue = new LinkedList<>(); + } + int size = random.nextInt(5) + 1; + for (int i = 0; i < size; i++) { + queue.add("element_" + random.nextInt(1000)); + } + return queue; + } + // Если enum - возвращаем рандомный енам + if (clazz.isEnum()) { + Object[] arr = clazz.getEnumConstants(); + return arr[random.nextInt(arr.length)]; + } + Constructor constructor = clazz.getDeclaredConstructors()[0]; + Class[] paramTypes = constructor.getParameterTypes(); + Object[] params = new Object[paramTypes.length]; + for (int i = 0; i < paramTypes.length; i++) { + params[i] = generateValueOfType(paramTypes[i]); + } + + constructor.setAccessible(true); + Object instance = constructor.newInstance(params); + return instance; + } } From f97fd216e85ff9d9e7c388d666d915209b7d9165 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Tue, 14 Oct 2025 23:12:35 +0300 Subject: [PATCH 03/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=BE=D0=B1=D1=80=D0=B0=D0=B1=D0=BE=D1=82=D0=BA=D1=83?= =?UTF-8?q?=20=D1=86=D0=B8=D0=BB=D0=B8=D1=87=D0=B5=D1=81=D0=BA=D0=B8=D1=85?= =?UTF-8?q?=20=D1=81=D1=82=D1=83=D1=80=D0=BA=D1=82=D1=83=D1=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/org/example/generator/Generator.java | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index b5be804..f046232 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -19,10 +19,6 @@ public Object generateValueOfType(Class clazz) throws InstantiationException, IllegalAccessException { - // Интерфейсе или абстрактные классы скипаем - if (clazz.isInterface() || Modifier.isAbstract(clazz.getModifiers())) { - return null; - } // Для интов генерируем рандомный инт if (clazz.equals(int.class) || clazz.equals(Integer.class)) {return random.nextInt(1000);} // Для даблов генерируем рандомный дабл @@ -76,7 +72,7 @@ public Object generateValueOfType(Class clazz) throws } // Если обьект - очередь, начинаем перебор по очередям if (Queue.class.isAssignableFrom(clazz)) { - Queue queue; + Queue queue = null; // Блокирующие очереди if (BlockingQueue.class.isAssignableFrom(clazz)) { if (ArrayBlockingQueue.class.isAssignableFrom(clazz)) { @@ -102,11 +98,17 @@ public Object generateValueOfType(Class clazz) throws Object[] arr = clazz.getEnumConstants(); return arr[random.nextInt(arr.length)]; } + String simpleName = clazz.getSimpleName(); Constructor constructor = clazz.getDeclaredConstructors()[0]; Class[] paramTypes = constructor.getParameterTypes(); - Object[] params = new Object[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { + // Если аттрибуты обьекты являются типом обьекта - + // ломаем цикл + String paramName = paramTypes[i].getSimpleName(); + if (simpleName.equals(paramName)) { + return null; + } params[i] = generateValueOfType(paramTypes[i]); } From 1e865bd6151848ad3c6cd8f6b8d7d2de53e2756b Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Tue, 14 Oct 2025 23:55:32 +0300 Subject: [PATCH 04/21] =?UTF-8?q?=D0=BE=D0=B1=D1=80=D0=B0=D0=B1=D0=BE?= =?UTF-8?q?=D1=82=D0=BA=D0=B0=20=D0=BB=D0=B8=D1=81=D1=82=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/org/example/generator/Generator.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index f046232..9acca38 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -43,6 +43,16 @@ public Object generateValueOfType(Class clazz) throws if (clazz.equals(byte.class) || clazz.equals(Byte.class)) {return (byte) random.nextInt(Byte.MAX_VALUE);} // Если дата - генерим текущую дату if (clazz.equals(Date.class)) {return new Date();} + if (clazz.equals(List.class) || clazz.equals(ArrayList.class)) { + List list = new ArrayList<>(); + int randomIndex = random.nextInt(100); + System.out.println(clazz.getClass().getComponentType()); + for (int i = 0; i < randomIndex; i++) { + Object obj = generateValueOfType(clazz.getClass()); + list.add(obj); + } + return list; + } // Обработка атомиков if (AtomicInteger.class.equals(clazz)) {return new AtomicInteger(random.nextInt(Integer.MAX_VALUE));} @@ -98,6 +108,10 @@ public Object generateValueOfType(Class clazz) throws Object[] arr = clazz.getEnumConstants(); return arr[random.nextInt(arr.length)]; } + if (clazz.isInterface()) { + System.out.println(clazz.getSimpleName()); + return null; + } String simpleName = clazz.getSimpleName(); Constructor constructor = clazz.getDeclaredConstructors()[0]; Class[] paramTypes = constructor.getParameterTypes(); From 99940a2a5bfd8df8e3a1fe29939bad5e2531f921 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Wed, 15 Oct 2025 22:13:45 +0300 Subject: [PATCH 05/21] fixed output --- src/main/java/org/example/GenerateExample.java | 2 +- src/main/java/org/example/generator/Generator.java | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index 94e27b3..1f3f7f3 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -19,7 +19,7 @@ public static void main(String[] args) { for (Field field : fields) { field.setAccessible(true); System.out.println( - "Field " + field.getName() + " with type " + field.getType() + " " + field.get(generated) + "Field " + field.getName() + " with type:" + field.getType() + " and value:" + field.get(generated) ); } } catch (Throwable e) { diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 9acca38..8a9dd5b 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -46,7 +46,6 @@ public Object generateValueOfType(Class clazz) throws if (clazz.equals(List.class) || clazz.equals(ArrayList.class)) { List list = new ArrayList<>(); int randomIndex = random.nextInt(100); - System.out.println(clazz.getClass().getComponentType()); for (int i = 0; i < randomIndex; i++) { Object obj = generateValueOfType(clazz.getClass()); list.add(obj); @@ -117,7 +116,7 @@ public Object generateValueOfType(Class clazz) throws Class[] paramTypes = constructor.getParameterTypes(); Object[] params = new Object[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { - // Если аттрибуты обьекты являются типом обьекта - + // Если аттрибуты обьекта являются типом обьекта - // ломаем цикл String paramName = paramTypes[i].getSimpleName(); if (simpleName.equals(paramName)) { From 901bcf288440438af3b45c490039087af364ff81 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Wed, 15 Oct 2025 23:02:20 +0300 Subject: [PATCH 06/21] refactor, make code prettier --- src/main/java/org/example/classes/Cart.java | 10 +- .../example/generator/AtomicGenerator.java | 29 ++++ .../java/org/example/generator/Generator.java | 131 ++++++++---------- .../example/generator/PrimitiveGenerator.java | 42 ++++++ .../org/example/generator/QueueGenerator.java | 54 ++++++++ .../example/generator/SequenceGenerator.java | 22 +++ .../org/example/generator/TypeGenerator.java | 25 ++++ 7 files changed, 233 insertions(+), 80 deletions(-) create mode 100644 src/main/java/org/example/generator/AtomicGenerator.java create mode 100644 src/main/java/org/example/generator/PrimitiveGenerator.java create mode 100644 src/main/java/org/example/generator/QueueGenerator.java create mode 100644 src/main/java/org/example/generator/SequenceGenerator.java create mode 100644 src/main/java/org/example/generator/TypeGenerator.java diff --git a/src/main/java/org/example/classes/Cart.java b/src/main/java/org/example/classes/Cart.java index 965237d..4ea73df 100644 --- a/src/main/java/org/example/classes/Cart.java +++ b/src/main/java/org/example/classes/Cart.java @@ -3,19 +3,17 @@ import java.util.List; 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/generator/AtomicGenerator.java b/src/main/java/org/example/generator/AtomicGenerator.java new file mode 100644 index 0000000..4d6ba65 --- /dev/null +++ b/src/main/java/org/example/generator/AtomicGenerator.java @@ -0,0 +1,29 @@ +package main.java.org.example.generator; + +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); + return supplier.get(); + + } +} diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 8a9dd5b..5ddf094 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -1,48 +1,62 @@ package org.example.generator; +import main.java.org.example.generator.AtomicGenerator; +import main.java.org.example.generator.PrimitiveGenerator; +import main.java.org.example.generator.QueueGenerator; + import java.lang.reflect.*; -import java.math.BigDecimal; -import java.math.BigInteger; import java.util.*; import java.util.concurrent.*; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.concurrent.atomic.AtomicLong; -import java.util.concurrent.atomic.AtomicReference; + public class Generator { private final Random random = new Random(); + private final PrimitiveGenerator primitiveGenerator = new PrimitiveGenerator(); + private final AtomicGenerator atomicGenerator = new AtomicGenerator(); + private final QueueGenerator queueGenerator = new QueueGenerator(); public Object generateValueOfType(Class clazz) throws InvocationTargetException, InstantiationException, IllegalAccessException { - // Для интов генерируем рандомный инт - if (clazz.equals(int.class) || clazz.equals(Integer.class)) {return random.nextInt(1000);} - // Для даблов генерируем рандомный дабл - if (clazz.equals(double.class) || clazz.equals(Double.class)) {return random.nextDouble();} - // Если строка генерируем строку с префиксом в виде рандомного числа - if (clazz.equals(String.class)) {return "some_string_"+random.nextInt(1000);} - // Если буль - рандомный буль - if (clazz.equals(boolean.class) || clazz.equals(Boolean.class)) {return random.nextBoolean();} - // Если плавающая точка - рандомную плавающую точка - if (clazz.equals(float.class) || clazz.equals(Float.class)) {return random.nextFloat();} - // Если лонг - генерируем рандомный лонг - if (clazz.equals(long.class) || clazz.equals(Long.class)) {return random.nextLong();} - // Если большое число - генерируем рандомное большое число - if (clazz.equals(BigDecimal.class)) {return new BigDecimal(random.nextDouble());} - // Если большой инт - генерируем большой инт - if (clazz.equals(BigInteger.class)) {return new BigInteger(String.valueOf(random.nextLong()));} - // Если символ - рандомный символ - if (clazz.equals(char.class) || clazz.equals(Character.class)) {return (char) ('a' + random.nextInt(26));} - // Если шорт - генерируем рандомный шорт - if (clazz.equals(short.class) || clazz.equals(Short.class)) {return (short) random.nextInt(Short.MAX_VALUE);} - // Если байт - генерируем рандомный байт - if (clazz.equals(byte.class) || clazz.equals(Byte.class)) {return (byte) random.nextInt(Byte.MAX_VALUE);} - // Если дата - генерим текущую дату - if (clazz.equals(Date.class)) {return new Date();} + 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; + } + Object sequenceValue = generateSequence(clazz); + if (sequenceValue != null) { + return sequenceValue; + } + Object mapValue = generateMap(clazz); + if (mapValue != null) { + return mapValue; + } + if (clazz.isEnum()) { + Object[] arr = clazz.getEnumConstants(); + return arr[random.nextInt(arr.length)]; + } + if (clazz.isInterface()) { + return null; + } + Object generatedType = generateType(clazz); + return generatedType; + } + + private Object generateSequence(Class clazz) throws + InvocationTargetException, + InstantiationException, + IllegalAccessException + { if (clazz.equals(List.class) || clazz.equals(ArrayList.class)) { List list = new ArrayList<>(); int randomIndex = random.nextInt(100); @@ -52,15 +66,6 @@ public Object generateValueOfType(Class clazz) throws } return list; } - - // Обработка атомиков - if (AtomicInteger.class.equals(clazz)) {return new AtomicInteger(random.nextInt(Integer.MAX_VALUE));} - if (AtomicLong.class.equals(clazz)) {return new AtomicLong(random.nextInt(Integer.MAX_VALUE));} - if (AtomicBoolean.class.equals(clazz)) {return new AtomicBoolean(random.nextBoolean());} - if (AtomicReference.class.equals(clazz)) {return new AtomicReference<>(random.nextLong());} - - - // Если последовательнсть то генерируем с рандомным количеством элементов if (clazz.isArray()) { int randomIndex = random.nextInt(100); Object arr = Array.newInstance(clazz.getComponentType(), randomIndex); @@ -69,7 +74,11 @@ public Object generateValueOfType(Class clazz) throws } return arr; } - // Если мапа - генерируем либо обычную мапу, либо ее конкурентную версию + return null; + } + + private Object generateMap(Class clazz) + { if (Map.class.isAssignableFrom(clazz)) { Map map; if (ConcurrentHashMap.class.isAssignableFrom(clazz)) { @@ -79,45 +88,19 @@ public Object generateValueOfType(Class clazz) throws } return map; } - // Если обьект - очередь, начинаем перебор по очередям - if (Queue.class.isAssignableFrom(clazz)) { - Queue queue = null; - // Блокирующие очереди - if (BlockingQueue.class.isAssignableFrom(clazz)) { - if (ArrayBlockingQueue.class.isAssignableFrom(clazz)) { - queue = new ArrayBlockingQueue(10); - } else if (LinkedBlockingQueue.class.isAssignableFrom(clazz)) { - queue = new LinkedBlockingQueue(10); - } - // Конкурентная очередь - } else if (ConcurrentLinkedQueue.class.isAssignableFrom(clazz)) { - queue = new ConcurrentLinkedQueue(); - } else { - // Обычная очередь - queue = new LinkedList<>(); - } - int size = random.nextInt(5) + 1; - for (int i = 0; i < size; i++) { - queue.add("element_" + random.nextInt(1000)); - } - return queue; - } - // Если enum - возвращаем рандомный енам - if (clazz.isEnum()) { - Object[] arr = clazz.getEnumConstants(); - return arr[random.nextInt(arr.length)]; - } - if (clazz.isInterface()) { - System.out.println(clazz.getSimpleName()); - return null; - } + return null; + } + + private Object generateType(Class clazz) throws + InvocationTargetException, + InstantiationException, + IllegalAccessException + { String simpleName = clazz.getSimpleName(); Constructor constructor = clazz.getDeclaredConstructors()[0]; Class[] paramTypes = constructor.getParameterTypes(); Object[] params = new Object[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { - // Если аттрибуты обьекта являются типом обьекта - - // ломаем цикл String paramName = paramTypes[i].getSimpleName(); if (simpleName.equals(paramName)) { return null; 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..bf061da --- /dev/null +++ b/src/main/java/org/example/generator/PrimitiveGenerator.java @@ -0,0 +1,42 @@ +package main.java.org.example.generator; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import java.util.Random; +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); + return supplier.get(); + } +} 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..015143c --- /dev/null +++ b/src/main/java/org/example/generator/QueueGenerator.java @@ -0,0 +1,54 @@ +package main.java.org.example.generator; + +import java.util.*; +import java.util.concurrent.ArrayBlockingQueue; +import java.util.concurrent.BlockingQueue; +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<>(10); + fillQueue(q); + return q; + }); + queueGenerator.put(LinkedBlockingQueue.class, () -> { + Queue q = new LinkedBlockingQueue<>(10); + fillQueue(q); + return q; + }); + queueGenerator.put(ConcurrentLinkedQueue.class, () -> { + Queue q = new LinkedBlockingQueue<>(10); + fillQueue(q); + return q; + }); + queueGenerator.put(ConcurrentLinkedQueue.class, () -> { + Queue q = new ConcurrentLinkedQueue<>(); + fillQueue(q); + return q; + }); + queueGenerator.put(LinkedList.class, () -> { + Queue q = new LinkedList<>(); + fillQueue(q); + return q; + }); + } + + private void fillQueue(Queue queue) { + int size = random.nextInt(1000) + 1; + for (int i = 0; i < size; i++) { + queue.add("element_" + random.nextInt(1000)); + } + } + + public Object generate(Class clazz) { + Supplier supplier = queueGenerator.get(clazz); + return supplier.get(); + } +} 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..b24bbe5 --- /dev/null +++ b/src/main/java/org/example/generator/SequenceGenerator.java @@ -0,0 +1,22 @@ +package main.java.org.example.generator; + +import java.util.*; +import java.util.function.Supplier; + +public class SequenceGenerator { + + private final Random random = new Random(); + private final Map, Supplier> generators = new HashMap<>(); + + public SequenceGenerator() { + generators.put(List.class, () -> { + List list = new ArrayList<>(); + int randomIndex = random.nextInt(100); + for (int i = 0; i < randomIndex; i++) { + Object obj = generateValueOfType(clazz.getClass()); + list.add(obj); + } + return list; + }); + } +} diff --git a/src/main/java/org/example/generator/TypeGenerator.java b/src/main/java/org/example/generator/TypeGenerator.java new file mode 100644 index 0000000..2c99240 --- /dev/null +++ b/src/main/java/org/example/generator/TypeGenerator.java @@ -0,0 +1,25 @@ +package main.java.org.example.generator; + +import java.lang.reflect.Constructor; + +public class TypeGenerator { + public Object generate(Class clazz) { + String simpleName = clazz.getSimpleName(); + Constructor constructor = clazz.getDeclaredConstructors()[0]; + Class[] paramTypes = constructor.getParameterTypes(); + Object[] params = new Object[paramTypes.length]; + for (int i = 0; i < paramTypes.length; i++) { + // Если аттрибуты обьекта являются типом обьекта - + // ломаем цикл + String paramName = paramTypes[i].getSimpleName(); + if (simpleName.equals(paramName)) { + return null; + } + params[i] = generateValueOfType(paramTypes[i]); + } + + constructor.setAccessible(true); + Object instance = constructor.newInstance(params); + return instance; + } +} From 0faf9ba6b747f804359d179dc9a8f79ee86775b9 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Wed, 15 Oct 2025 23:04:08 +0300 Subject: [PATCH 07/21] removed unused classes --- .../example/generator/AtomicGenerator.java | 1 - .../example/generator/PrimitiveGenerator.java | 3 ++- .../org/example/generator/QueueGenerator.java | 10 +++++--- .../example/generator/SequenceGenerator.java | 22 ---------------- .../org/example/generator/TypeGenerator.java | 25 ------------------- 5 files changed, 8 insertions(+), 53 deletions(-) delete mode 100644 src/main/java/org/example/generator/SequenceGenerator.java delete mode 100644 src/main/java/org/example/generator/TypeGenerator.java diff --git a/src/main/java/org/example/generator/AtomicGenerator.java b/src/main/java/org/example/generator/AtomicGenerator.java index 4d6ba65..ba6d986 100644 --- a/src/main/java/org/example/generator/AtomicGenerator.java +++ b/src/main/java/org/example/generator/AtomicGenerator.java @@ -24,6 +24,5 @@ public AtomicGenerator() { public Object generate(Class clazz) { Supplier supplier = generators.get(clazz); return supplier.get(); - } } diff --git a/src/main/java/org/example/generator/PrimitiveGenerator.java b/src/main/java/org/example/generator/PrimitiveGenerator.java index bf061da..f88750f 100644 --- a/src/main/java/org/example/generator/PrimitiveGenerator.java +++ b/src/main/java/org/example/generator/PrimitiveGenerator.java @@ -35,7 +35,8 @@ public PrimitiveGenerator() { generators.put(Date.class, Date::new); } - public Object generate(Class clazz) { + public Object generate(Class clazz) + { Supplier supplier = generators.get(clazz); return supplier.get(); } diff --git a/src/main/java/org/example/generator/QueueGenerator.java b/src/main/java/org/example/generator/QueueGenerator.java index 015143c..35370ae 100644 --- a/src/main/java/org/example/generator/QueueGenerator.java +++ b/src/main/java/org/example/generator/QueueGenerator.java @@ -2,7 +2,6 @@ import java.util.*; import java.util.concurrent.ArrayBlockingQueue; -import java.util.concurrent.BlockingQueue; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.function.Supplier; @@ -12,7 +11,8 @@ public class QueueGenerator { private final Random random = new Random(); private final Map, Supplier> queueGenerator = new HashMap<>(); - public QueueGenerator() { + public QueueGenerator() + { queueGenerator.put(ArrayBlockingQueue.class, () -> { Queue q = new ArrayBlockingQueue<>(10); fillQueue(q); @@ -40,14 +40,16 @@ public QueueGenerator() { }); } - private void fillQueue(Queue queue) { + private void fillQueue(Queue queue) + { int size = random.nextInt(1000) + 1; for (int i = 0; i < size; i++) { queue.add("element_" + random.nextInt(1000)); } } - public Object generate(Class clazz) { + public Object generate(Class clazz) + { Supplier supplier = queueGenerator.get(clazz); return supplier.get(); } diff --git a/src/main/java/org/example/generator/SequenceGenerator.java b/src/main/java/org/example/generator/SequenceGenerator.java deleted file mode 100644 index b24bbe5..0000000 --- a/src/main/java/org/example/generator/SequenceGenerator.java +++ /dev/null @@ -1,22 +0,0 @@ -package main.java.org.example.generator; - -import java.util.*; -import java.util.function.Supplier; - -public class SequenceGenerator { - - private final Random random = new Random(); - private final Map, Supplier> generators = new HashMap<>(); - - public SequenceGenerator() { - generators.put(List.class, () -> { - List list = new ArrayList<>(); - int randomIndex = random.nextInt(100); - for (int i = 0; i < randomIndex; i++) { - Object obj = generateValueOfType(clazz.getClass()); - list.add(obj); - } - return list; - }); - } -} diff --git a/src/main/java/org/example/generator/TypeGenerator.java b/src/main/java/org/example/generator/TypeGenerator.java deleted file mode 100644 index 2c99240..0000000 --- a/src/main/java/org/example/generator/TypeGenerator.java +++ /dev/null @@ -1,25 +0,0 @@ -package main.java.org.example.generator; - -import java.lang.reflect.Constructor; - -public class TypeGenerator { - public Object generate(Class clazz) { - String simpleName = clazz.getSimpleName(); - Constructor constructor = clazz.getDeclaredConstructors()[0]; - Class[] paramTypes = constructor.getParameterTypes(); - Object[] params = new Object[paramTypes.length]; - for (int i = 0; i < paramTypes.length; i++) { - // Если аттрибуты обьекта являются типом обьекта - - // ломаем цикл - String paramName = paramTypes[i].getSimpleName(); - if (simpleName.equals(paramName)) { - return null; - } - params[i] = generateValueOfType(paramTypes[i]); - } - - constructor.setAccessible(true); - Object instance = constructor.newInstance(params); - return instance; - } -} From 7a1863d74ab229072d59b546f1b2cea6cabdb4f2 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Wed, 15 Oct 2025 23:22:49 +0300 Subject: [PATCH 08/21] moved sequncegenerato --- .../java/org/example/generator/Generator.java | 29 ++----------- .../example/generator/SequenceGenerator.java | 43 +++++++++++++++++++ 2 files changed, 46 insertions(+), 26 deletions(-) create mode 100644 src/main/java/org/example/generator/SequenceGenerator.java diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 5ddf094..5b25ee7 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -3,6 +3,7 @@ import main.java.org.example.generator.AtomicGenerator; import main.java.org.example.generator.PrimitiveGenerator; import main.java.org.example.generator.QueueGenerator; +import main.java.org.example.generator.SequenceGenerator; import java.lang.reflect.*; import java.util.*; @@ -15,6 +16,7 @@ public class Generator { private final PrimitiveGenerator primitiveGenerator = new PrimitiveGenerator(); private final AtomicGenerator atomicGenerator = new AtomicGenerator(); private final QueueGenerator queueGenerator = new QueueGenerator(); + private final SequenceGenerator sequenceGenerator = new SequenceGenerator(); public Object generateValueOfType(Class clazz) throws InvocationTargetException, @@ -33,7 +35,7 @@ public Object generateValueOfType(Class clazz) throws if (queueValue != null) { return queueValue; } - Object sequenceValue = generateSequence(clazz); + Object sequenceValue = sequenceGenerator.generate(clazz); if (sequenceValue != null) { return sequenceValue; } @@ -52,31 +54,6 @@ public Object generateValueOfType(Class clazz) throws return generatedType; } - private Object generateSequence(Class clazz) throws - InvocationTargetException, - InstantiationException, - IllegalAccessException - { - if (clazz.equals(List.class) || clazz.equals(ArrayList.class)) { - List list = new ArrayList<>(); - int randomIndex = random.nextInt(100); - for (int i = 0; i < randomIndex; i++) { - Object obj = generateValueOfType(clazz.getClass()); - list.add(obj); - } - return list; - } - if (clazz.isArray()) { - int randomIndex = random.nextInt(100); - Object arr = Array.newInstance(clazz.getComponentType(), randomIndex); - for (int i = 0; i < randomIndex; i++) { - Array.set(arr, i, generateValueOfType(clazz.getComponentType())); - } - return arr; - } - return null; - } - private Object generateMap(Class clazz) { if (Map.class.isAssignableFrom(clazz)) { 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..7f16530 --- /dev/null +++ b/src/main/java/org/example/generator/SequenceGenerator.java @@ -0,0 +1,43 @@ +package main.java.org.example.generator; + +import java.lang.reflect.Array; +import java.lang.reflect.InvocationTargetException; +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; + } +} From a52296845e6bea9b1031db24ca0e4a3e32717395 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Fri, 17 Oct 2025 17:18:09 +0300 Subject: [PATCH 09/21] =?UTF-8?q?=D1=81=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20?= =?UTF-8?q?=D0=BA=D0=BE=D0=B4=20=D0=BF=D0=BE=D0=BA=D1=80=D0=B0=D1=81=D0=B8?= =?UTF-8?q?=D0=B2=D0=B5=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../example/generator/AtomicGenerator.java | 3 + .../java/org/example/generator/Generator.java | 22 +------ .../org/example/generator/MapGenerator.java | 60 +++++++++++++++++++ .../example/generator/PrimitiveGenerator.java | 10 ++-- .../org/example/generator/QueueGenerator.java | 7 ++- .../example/generator/SequenceGenerator.java | 1 - 6 files changed, 76 insertions(+), 27 deletions(-) create mode 100644 src/main/java/org/example/generator/MapGenerator.java diff --git a/src/main/java/org/example/generator/AtomicGenerator.java b/src/main/java/org/example/generator/AtomicGenerator.java index ba6d986..c2268a4 100644 --- a/src/main/java/org/example/generator/AtomicGenerator.java +++ b/src/main/java/org/example/generator/AtomicGenerator.java @@ -23,6 +23,9 @@ public AtomicGenerator() { 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/Generator.java b/src/main/java/org/example/generator/Generator.java index 5b25ee7..adbbbc3 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -1,9 +1,6 @@ package org.example.generator; -import main.java.org.example.generator.AtomicGenerator; -import main.java.org.example.generator.PrimitiveGenerator; -import main.java.org.example.generator.QueueGenerator; -import main.java.org.example.generator.SequenceGenerator; +import main.java.org.example.generator.*; import java.lang.reflect.*; import java.util.*; @@ -17,6 +14,7 @@ public class Generator { private final AtomicGenerator atomicGenerator = new AtomicGenerator(); private final QueueGenerator queueGenerator = new QueueGenerator(); private final SequenceGenerator sequenceGenerator = new SequenceGenerator(); + private final MapGenerator mapGenerator = new MapGenerator(); public Object generateValueOfType(Class clazz) throws InvocationTargetException, @@ -39,7 +37,7 @@ public Object generateValueOfType(Class clazz) throws if (sequenceValue != null) { return sequenceValue; } - Object mapValue = generateMap(clazz); + Object mapValue = mapGenerator.generate(clazz); if (mapValue != null) { return mapValue; } @@ -54,20 +52,6 @@ public Object generateValueOfType(Class clazz) throws return generatedType; } - private Object generateMap(Class clazz) - { - if (Map.class.isAssignableFrom(clazz)) { - Map map; - if (ConcurrentHashMap.class.isAssignableFrom(clazz)) { - map = new ConcurrentHashMap<>(); - } else { - map = new HashMap<>(); - } - return map; - } - return null; - } - private Object generateType(Class clazz) throws InvocationTargetException, InstantiationException, 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..c64e586 --- /dev/null +++ b/src/main/java/org/example/generator/MapGenerator.java @@ -0,0 +1,60 @@ +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 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/PrimitiveGenerator.java b/src/main/java/org/example/generator/PrimitiveGenerator.java index f88750f..fdf547e 100644 --- a/src/main/java/org/example/generator/PrimitiveGenerator.java +++ b/src/main/java/org/example/generator/PrimitiveGenerator.java @@ -2,10 +2,7 @@ import java.math.BigDecimal; import java.math.BigInteger; -import java.util.Date; -import java.util.HashMap; -import java.util.Map; -import java.util.Random; +import java.util.*; import java.util.function.Supplier; public class PrimitiveGenerator { @@ -38,6 +35,9 @@ public PrimitiveGenerator() { public Object generate(Class clazz) { Supplier supplier = generators.get(clazz); - return supplier.get(); + 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 index 35370ae..903adb8 100644 --- a/src/main/java/org/example/generator/QueueGenerator.java +++ b/src/main/java/org/example/generator/QueueGenerator.java @@ -44,13 +44,16 @@ private void fillQueue(Queue queue) { int size = random.nextInt(1000) + 1; for (int i = 0; i < size; i++) { - queue.add("element_" + random.nextInt(1000)); + queue.add(new Object()); } } public Object generate(Class clazz) { Supplier supplier = queueGenerator.get(clazz); - return supplier.get(); + 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 index 7f16530..6a47797 100644 --- a/src/main/java/org/example/generator/SequenceGenerator.java +++ b/src/main/java/org/example/generator/SequenceGenerator.java @@ -1,7 +1,6 @@ package main.java.org.example.generator; import java.lang.reflect.Array; -import java.lang.reflect.InvocationTargetException; import java.util.*; import java.util.function.Supplier; From 4c09579acded1e97d2be2e5d2874df859aa0a850 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Fri, 17 Oct 2025 17:32:51 +0300 Subject: [PATCH 10/21] =?UTF-8?q?=D0=B4=D0=B8=D1=80=D0=B5=D0=BA=D1=82?= =?UTF-8?q?=D0=BE=D1=80=D0=B8=D1=8F=20=D1=81=20=D1=82=D0=B5=D1=81=D1=82?= =?UTF-8?q?=D0=B0=D0=BC=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/org/example/generator/AtomicGenerator.java | 6 ++++-- .../java/org/example/generator/MapGenerator.java | 3 ++- .../org/example/generator/PrimitiveGenerator.java | 3 ++- .../org/example/generator/SequenceGenerator.java | 12 ++++++++---- 4 files changed, 16 insertions(+), 8 deletions(-) diff --git a/src/main/java/org/example/generator/AtomicGenerator.java b/src/main/java/org/example/generator/AtomicGenerator.java index c2268a4..3beec38 100644 --- a/src/main/java/org/example/generator/AtomicGenerator.java +++ b/src/main/java/org/example/generator/AtomicGenerator.java @@ -13,7 +13,8 @@ public class AtomicGenerator { private final Random random = new Random(); private final Map, Supplier> generators; - public AtomicGenerator() { + 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))); @@ -21,7 +22,8 @@ public AtomicGenerator() { generators.put(AtomicReference.class, () -> new AtomicReference<>(random.nextInt())); } - public Object generate(Class clazz) { + public Object generate(Class clazz) + { Supplier supplier = generators.get(clazz); if (supplier == null) { return null; diff --git a/src/main/java/org/example/generator/MapGenerator.java b/src/main/java/org/example/generator/MapGenerator.java index c64e586..ac9f185 100644 --- a/src/main/java/org/example/generator/MapGenerator.java +++ b/src/main/java/org/example/generator/MapGenerator.java @@ -8,7 +8,8 @@ public class MapGenerator { private final Random random = new Random(); private final Map, Supplier> generators = new HashMap<>(); - public MapGenerator() { + public MapGenerator() + { generators.put(HashMap.class, () -> { HashMap map = new HashMap<>(); fillMap(map); diff --git a/src/main/java/org/example/generator/PrimitiveGenerator.java b/src/main/java/org/example/generator/PrimitiveGenerator.java index fdf547e..86ed3da 100644 --- a/src/main/java/org/example/generator/PrimitiveGenerator.java +++ b/src/main/java/org/example/generator/PrimitiveGenerator.java @@ -9,7 +9,8 @@ public class PrimitiveGenerator { private final Random random = new Random(); private final Map, Supplier> generators = new HashMap<>(); - public PrimitiveGenerator() { + public PrimitiveGenerator() + { generators.put(int.class, () -> random.nextInt(1000)); generators.put(Integer.class, () -> random.nextInt(1000)); generators.put(double.class, () -> random.nextDouble()); diff --git a/src/main/java/org/example/generator/SequenceGenerator.java b/src/main/java/org/example/generator/SequenceGenerator.java index 6a47797..f59dcf0 100644 --- a/src/main/java/org/example/generator/SequenceGenerator.java +++ b/src/main/java/org/example/generator/SequenceGenerator.java @@ -8,13 +8,15 @@ public class SequenceGenerator { private final Random random = new Random(); private final Map, Supplier> sequnceGenerator = new HashMap<>(); - public SequenceGenerator() { + 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) { + public Object generate(Class clazz) + { Supplier supplier = sequnceGenerator.get(clazz); if (supplier != null) { return supplier.get(); @@ -22,7 +24,8 @@ public Object generate(Class clazz) { return null; } - private List generateList() { + private List generateList() + { List list = new ArrayList<>(); int num = random.nextInt(1000); for (int i = 0; i < num; i++) { @@ -31,7 +34,8 @@ private List generateList() { return list; } - private Object generateArray() { + private Object generateArray() + { int randomIndex = random.nextInt(100); Object arr = Array.newInstance(Object.class, randomIndex); for (int i = 0; i < randomIndex; i++) { From 6574c7cf5d14c214075f6aefc47cfed349c3bed9 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Fri, 17 Oct 2025 18:08:22 +0300 Subject: [PATCH 11/21] =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=B4?= =?UTF-8?q?=D0=BB=D1=8F=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=82=D0=BE?= =?UTF-8?q?=D1=80=D0=B0=20=D0=B0=D1=82=D0=BE=D0=BC=D0=B8=D0=BA=D0=BE=D0=B2?= =?UTF-8?q?=20=D0=B8=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=82=D0=BE?= =?UTF-8?q?=D1=80=D0=B0=20=D0=BC=D0=B0=D0=BF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../example/generator/AtomicGenerator.java | 1 + .../org/example/generator/MapGenerator.java | 4 +- .../Generator/AtomicGeneratorTest.java | 52 +++++++++++++ .../org/example/Generator/GeneratorTest.java | 4 + .../example/Generator/MapGeneratorTest.java | 74 +++++++++++++++++++ .../example/Generator/PrimitiveGenrator.java | 4 + .../example/Generator/QueueGeneratorTest.java | 4 + .../Generator/SequenceGeneratorTest.java | 4 + 8 files changed, 145 insertions(+), 2 deletions(-) create mode 100644 src/test/java/org/example/Generator/AtomicGeneratorTest.java create mode 100644 src/test/java/org/example/Generator/GeneratorTest.java create mode 100644 src/test/java/org/example/Generator/MapGeneratorTest.java create mode 100644 src/test/java/org/example/Generator/PrimitiveGenrator.java create mode 100644 src/test/java/org/example/Generator/QueueGeneratorTest.java create mode 100644 src/test/java/org/example/Generator/SequenceGeneratorTest.java diff --git a/src/main/java/org/example/generator/AtomicGenerator.java b/src/main/java/org/example/generator/AtomicGenerator.java index 3beec38..3a6cc0f 100644 --- a/src/main/java/org/example/generator/AtomicGenerator.java +++ b/src/main/java/org/example/generator/AtomicGenerator.java @@ -1,5 +1,6 @@ package main.java.org.example.generator; +import java.io.Serializable; import java.util.HashMap; import java.util.Map; import java.util.Random; diff --git a/src/main/java/org/example/generator/MapGenerator.java b/src/main/java/org/example/generator/MapGenerator.java index ac9f185..259d81c 100644 --- a/src/main/java/org/example/generator/MapGenerator.java +++ b/src/main/java/org/example/generator/MapGenerator.java @@ -50,12 +50,12 @@ private void fillMap(Map map) } } - public Object generate(Class clazz) + public Map generate(Class clazz) { Supplier supplier = generators.get(clazz); if (supplier == null) { return null; } - return supplier.get(); + return (Map) supplier.get(); } } 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..4fadafd --- /dev/null +++ b/src/test/java/org/example/Generator/AtomicGeneratorTest.java @@ -0,0 +1,52 @@ +package test.java.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..173d750 --- /dev/null +++ b/src/test/java/org/example/Generator/GeneratorTest.java @@ -0,0 +1,4 @@ +package test.java.org.example.Generator; + +public class GeneratorTest { +} 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/PrimitiveGenrator.java b/src/test/java/org/example/Generator/PrimitiveGenrator.java new file mode 100644 index 0000000..b11d013 --- /dev/null +++ b/src/test/java/org/example/Generator/PrimitiveGenrator.java @@ -0,0 +1,4 @@ +package test.java.org.example.Generator; + +public class PrimitiveGenrator { +} 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..7aa703f --- /dev/null +++ b/src/test/java/org/example/Generator/QueueGeneratorTest.java @@ -0,0 +1,4 @@ +package test.java.org.example.Generator; + +public class QueueGeneratorTest { +} 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..b45e4d0 --- /dev/null +++ b/src/test/java/org/example/Generator/SequenceGeneratorTest.java @@ -0,0 +1,4 @@ +package test.java.org.example.Generator; + +public class SequenceGeneratorTest { +} From 56927beeb38692fa49185958bb8a9c7986aacb36 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Fri, 17 Oct 2025 18:34:03 +0300 Subject: [PATCH 12/21] =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=20=D0=BE=D0=B1?= =?UTF-8?q?=D1=8B=D1=87=D0=BD=D1=8B=D1=85=20=D1=82=D0=B8=D0=BF=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Generator/PrimitiveGeneratorTest.java | 183 ++++++++++++++++++ .../example/Generator/PrimitiveGenrator.java | 4 - 2 files changed, 183 insertions(+), 4 deletions(-) create mode 100644 src/test/java/org/example/Generator/PrimitiveGeneratorTest.java delete mode 100644 src/test/java/org/example/Generator/PrimitiveGenrator.java 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/PrimitiveGenrator.java b/src/test/java/org/example/Generator/PrimitiveGenrator.java deleted file mode 100644 index b11d013..0000000 --- a/src/test/java/org/example/Generator/PrimitiveGenrator.java +++ /dev/null @@ -1,4 +0,0 @@ -package test.java.org.example.Generator; - -public class PrimitiveGenrator { -} From ccf67ac685cee9d01a44c003976ad4d64abd7fcb Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Fri, 17 Oct 2025 18:50:39 +0300 Subject: [PATCH 13/21] =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=B4?= =?UTF-8?q?=D0=BB=D1=8F=20=D0=BF=D0=BE=D1=81=D0=BB=D0=B5=D0=B4=D0=BE=D0=B2?= =?UTF-8?q?=D0=B0=D1=82=D0=B5=D0=BB=D1=8C=D0=BD=D0=BE=D1=81=D1=82=D0=B5?= =?UTF-8?q?=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Generator/SequenceGeneratorTest.java | 53 ++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/src/test/java/org/example/Generator/SequenceGeneratorTest.java b/src/test/java/org/example/Generator/SequenceGeneratorTest.java index b45e4d0..39787db 100644 --- a/src/test/java/org/example/Generator/SequenceGeneratorTest.java +++ b/src/test/java/org/example/Generator/SequenceGeneratorTest.java @@ -1,4 +1,55 @@ -package test.java.org.example.Generator; +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); + } } From 9759ab9c31bf2ac6269c753a80d39a41c70453c2 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Fri, 17 Oct 2025 19:03:15 +0300 Subject: [PATCH 14/21] =?UTF-8?q?=D0=BF=D0=BE=D0=BF=D1=80=D0=B0=D0=B2?= =?UTF-8?q?=D0=B8=D0=BB=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=82=D0=BE?= =?UTF-8?q?=D1=80=20=D0=BE=D1=87=D0=B5=D1=80=D0=B5=D0=B4=D0=B5=D0=B9,=20?= =?UTF-8?q?=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D0=BD=D0=B0=20=D0=BD=D0=B5?= =?UTF-8?q?=D0=B3=D0=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../org/example/generator/QueueGenerator.java | 16 ++----- .../example/Generator/QueueGeneratorTest.java | 42 ++++++++++++++++++- 2 files changed, 44 insertions(+), 14 deletions(-) diff --git a/src/main/java/org/example/generator/QueueGenerator.java b/src/main/java/org/example/generator/QueueGenerator.java index 903adb8..1124730 100644 --- a/src/main/java/org/example/generator/QueueGenerator.java +++ b/src/main/java/org/example/generator/QueueGenerator.java @@ -14,17 +14,12 @@ public class QueueGenerator { public QueueGenerator() { queueGenerator.put(ArrayBlockingQueue.class, () -> { - Queue q = new ArrayBlockingQueue<>(10); + Queue q = new ArrayBlockingQueue<>(100); fillQueue(q); return q; }); queueGenerator.put(LinkedBlockingQueue.class, () -> { - Queue q = new LinkedBlockingQueue<>(10); - fillQueue(q); - return q; - }); - queueGenerator.put(ConcurrentLinkedQueue.class, () -> { - Queue q = new LinkedBlockingQueue<>(10); + Queue q = new LinkedBlockingQueue<>(100); fillQueue(q); return q; }); @@ -33,16 +28,11 @@ public QueueGenerator() fillQueue(q); return q; }); - queueGenerator.put(LinkedList.class, () -> { - Queue q = new LinkedList<>(); - fillQueue(q); - return q; - }); } private void fillQueue(Queue queue) { - int size = random.nextInt(1000) + 1; + int size = random.nextInt(100); for (int i = 0; i < size; i++) { queue.add(new Object()); } diff --git a/src/test/java/org/example/Generator/QueueGeneratorTest.java b/src/test/java/org/example/Generator/QueueGeneratorTest.java index 7aa703f..d675636 100644 --- a/src/test/java/org/example/Generator/QueueGeneratorTest.java +++ b/src/test/java/org/example/Generator/QueueGeneratorTest.java @@ -1,4 +1,44 @@ -package test.java.org.example.Generator; +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.Queue; +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); + } } From 96fa855227a46999bdf401034170943070d90ddb Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Mon, 20 Oct 2025 21:37:46 +0300 Subject: [PATCH 15/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D1=81=20=D0=B3=D0=B5?= =?UTF-8?q?=D0=BD=D0=B5=D1=80=D0=B0=D1=82=D0=BE=D1=80=D0=BE=D0=BC=20=D1=80?= =?UTF-8?q?=D0=B0=D0=BD=D0=B4=D0=BE=D0=BC=D0=BD=D1=8B=D1=85=20=D0=BE=D0=B1?= =?UTF-8?q?=D1=8C=D0=B5=D0=BA=D1=82=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- build.gradle.kts | 2 + .../Generator/AtomicGeneratorTest.java | 2 +- .../org/example/Generator/GeneratorTest.java | 38 ++++++++++++++++++- .../example/Generator/QueueGeneratorTest.java | 1 - .../Generator/RandomClassGenerator.java | 28 ++++++++++++++ 5 files changed, 68 insertions(+), 3 deletions(-) create mode 100644 src/test/java/org/example/Generator/RandomClassGenerator.java 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/test/java/org/example/Generator/AtomicGeneratorTest.java b/src/test/java/org/example/Generator/AtomicGeneratorTest.java index 4fadafd..4f42c5c 100644 --- a/src/test/java/org/example/Generator/AtomicGeneratorTest.java +++ b/src/test/java/org/example/Generator/AtomicGeneratorTest.java @@ -1,4 +1,4 @@ -package test.java.org.example.Generator; +package org.example.Generator; import java.io.Serializable; import java.util.concurrent.atomic.AtomicBoolean; diff --git a/src/test/java/org/example/Generator/GeneratorTest.java b/src/test/java/org/example/Generator/GeneratorTest.java index 173d750..838ae44 100644 --- a/src/test/java/org/example/Generator/GeneratorTest.java +++ b/src/test/java/org/example/Generator/GeneratorTest.java @@ -1,4 +1,40 @@ -package test.java.org.example.Generator; +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/QueueGeneratorTest.java b/src/test/java/org/example/Generator/QueueGeneratorTest.java index d675636..07c0803 100644 --- a/src/test/java/org/example/Generator/QueueGeneratorTest.java +++ b/src/test/java/org/example/Generator/QueueGeneratorTest.java @@ -5,7 +5,6 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; -import java.util.Queue; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.LinkedBlockingQueue; 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; + } +} From 75c7c46233c21d5315741a9e00ffff0dbd535646 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Mon, 20 Oct 2025 21:45:48 +0300 Subject: [PATCH 16/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=B0=D0=BD=D0=BD=D0=BE=D1=82=D0=B0=D1=86=D0=B8=D1=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/org/example/GenerateExample.java | 2 +- src/main/java/org/example/annotation/Generatable.java | 11 +++++++++++ src/main/java/org/example/classes/BinaryTreeNode.java | 4 ++++ src/main/java/org/example/classes/Cart.java | 3 +++ src/main/java/org/example/classes/Example.java | 3 +++ src/main/java/org/example/classes/Product.java | 3 +++ src/main/java/org/example/classes/Rectangle.java | 3 +++ src/main/java/org/example/classes/Triangle.java | 3 +++ 8 files changed, 31 insertions(+), 1 deletion(-) create mode 100644 src/main/java/org/example/annotation/Generatable.java diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index 1f3f7f3..d25889a 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -8,7 +8,7 @@ public class GenerateExample { public static void main(String[] args) { var gen = new Generator(); try { - Object generated = gen.generateValueOfType(org.example.classes.Cart.class); + Object generated = gen.generateValueOfType(org.example.classes.BinaryTreeNode.class); if (generated == null) { System.out.println("Generated object is null"); return; 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 4ea73df..813b02e 100644 --- a/src/main/java/org/example/classes/Cart.java +++ b/src/main/java/org/example/classes/Cart.java @@ -1,7 +1,10 @@ package org.example.classes; +import org.example.annotation.Generatable; + import java.util.List; +@Generatable public class Cart { private List items; 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; From 8c75d198002aaea61b1d5740c86c22a96cb36814 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Sat, 8 Nov 2025 15:46:02 +0300 Subject: [PATCH 17/21] =?UTF-8?q?=D0=BE=D0=B3=D1=80=D0=B0=D0=BD=D0=B8?= =?UTF-8?q?=D1=87=D0=B8=D0=BB=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=86?= =?UTF-8?q?=D0=B8=D1=8E=20=D0=BE=D0=B1=D1=8C=D0=B5=D0=BA=D1=82=D0=BE=D0=B2?= =?UTF-8?q?=20=D0=B0=D0=BD=D0=BD=D0=BE=D1=82=D0=B0=D1=86=D0=B8=D0=B5=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/org/example/GenerateExample.java | 2 +- .../java/org/example/generator/Generator.java | 29 ++++++++++++------- 2 files changed, 19 insertions(+), 12 deletions(-) diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index d25889a..dfaade7 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -8,7 +8,7 @@ public class GenerateExample { public static void main(String[] args) { var gen = new Generator(); try { - Object generated = gen.generateValueOfType(org.example.classes.BinaryTreeNode.class); + Object generated = gen.generateValueOfType(org.example.classes.Triangle.class); if (generated == null) { System.out.println("Generated object is null"); return; diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index adbbbc3..14879f4 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -1,7 +1,9 @@ package org.example.generator; import main.java.org.example.generator.*; +import org.example.annotation.Generatable; +import java.lang.annotation.Annotation; import java.lang.reflect.*; import java.util.*; import java.util.concurrent.*; @@ -59,18 +61,23 @@ private Object generateType(Class clazz) throws { String simpleName = clazz.getSimpleName(); Constructor constructor = clazz.getDeclaredConstructors()[0]; - Class[] paramTypes = constructor.getParameterTypes(); - Object[] params = new Object[paramTypes.length]; - for (int i = 0; i < paramTypes.length; i++) { - String paramName = paramTypes[i].getSimpleName(); - if (simpleName.equals(paramName)) { - return null; + boolean annotation = clazz.isAnnotationPresent(Generatable.class); + if (annotation) { + Class[] paramTypes = constructor.getParameterTypes(); + Object[] params = new Object[paramTypes.length]; + for (int i = 0; i < paramTypes.length; i++) { + String paramName = paramTypes[i].getSimpleName(); + if (simpleName.equals(paramName)) { + return null; + } + params[i] = generateValueOfType(paramTypes[i]); } - params[i] = generateValueOfType(paramTypes[i]); - } - constructor.setAccessible(true); - Object instance = constructor.newInstance(params); - return instance; + constructor.setAccessible(true); + Object instance = constructor.newInstance(params); + return instance; + } else { + throw new IllegalArgumentException("Class " + clazz.getName() + " has no Generatable annotation"); + } } } From 2ac97b9573dcc59bb2378af92481c903194562f0 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Sat, 8 Nov 2025 16:30:58 +0300 Subject: [PATCH 18/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=BB=D0=B8=D0=BC=D0=B8=D1=82=20=D1=80=D0=B5=D0=BA?= =?UTF-8?q?=D1=83=D1=80=D1=81=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/org/example/GenerateExample.java | 3 ++- .../java/org/example/generator/Generator.java | 25 +++++++++---------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index dfaade7..1145eb7 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -8,7 +8,8 @@ public class GenerateExample { public static void main(String[] args) { var gen = new Generator(); try { - Object generated = gen.generateValueOfType(org.example.classes.Triangle.class); + int depth = 0; + Object generated = gen.generateValueOfType(org.example.classes.BinaryTreeNode.class, depth); if (generated == null) { System.out.println("Generated object is null"); return; diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 14879f4..1316188 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -3,7 +3,6 @@ import main.java.org.example.generator.*; import org.example.annotation.Generatable; -import java.lang.annotation.Annotation; import java.lang.reflect.*; import java.util.*; import java.util.concurrent.*; @@ -17,12 +16,17 @@ public class Generator { private final QueueGenerator queueGenerator = new QueueGenerator(); private final SequenceGenerator sequenceGenerator = new SequenceGenerator(); private final MapGenerator mapGenerator = new MapGenerator(); + private static final int MAX_DEPTH = 10; - public Object generateValueOfType(Class clazz) throws + public Object generateValueOfType(Class clazz, int depth) throws InvocationTargetException, InstantiationException, - IllegalAccessException + IllegalAccessException, + NoSuchMethodException { + if (depth > MAX_DEPTH) { + return null; + } Object primitiveValue = primitiveGenerator.generate(clazz); if (primitiveValue != null) { return primitiveValue; @@ -50,29 +54,24 @@ public Object generateValueOfType(Class clazz) throws if (clazz.isInterface()) { return null; } - Object generatedType = generateType(clazz); + Object generatedType = generateType(clazz, depth+1); return generatedType; } - private Object generateType(Class clazz) throws + private Object generateType(Class clazz, int depth) throws InvocationTargetException, InstantiationException, - IllegalAccessException + IllegalAccessException, + NoSuchMethodException { - String simpleName = clazz.getSimpleName(); Constructor constructor = clazz.getDeclaredConstructors()[0]; boolean annotation = clazz.isAnnotationPresent(Generatable.class); if (annotation) { Class[] paramTypes = constructor.getParameterTypes(); Object[] params = new Object[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { - String paramName = paramTypes[i].getSimpleName(); - if (simpleName.equals(paramName)) { - return null; - } - params[i] = generateValueOfType(paramTypes[i]); + params[i] = generateValueOfType(paramTypes[i], depth+1); } - constructor.setAccessible(true); Object instance = constructor.newInstance(params); return instance; From ef3cd831f3e0e5802fcab319b23051c6af5bcbe4 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Sat, 8 Nov 2025 16:52:26 +0300 Subject: [PATCH 19/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=BF=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=BA=D1=83=20isA?= =?UTF-8?q?ssignableFrom?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main/java/org/example/generator/Generator.java | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/src/main/java/org/example/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index 1316188..d4b2e31 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -39,13 +39,11 @@ public Object generateValueOfType(Class clazz, int depth) throws if (queueValue != null) { return queueValue; } - Object sequenceValue = sequenceGenerator.generate(clazz); - if (sequenceValue != null) { - return sequenceValue; + if (Collection.class.isAssignableFrom(clazz)) { + return sequenceGenerator.generate(clazz); } - Object mapValue = mapGenerator.generate(clazz); - if (mapValue != null) { - return mapValue; + if (Map.class.isAssignableFrom(clazz)) { + return mapGenerator.generate(clazz); } if (clazz.isEnum()) { Object[] arr = clazz.getEnumConstants(); From 192cbaabb4f51da588a271e3b11fcb4760b7fe78 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Sat, 8 Nov 2025 17:33:58 +0300 Subject: [PATCH 20/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D1=8E?= =?UTF-8?q?=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=BE=D0=B2=20=D0=BD=D0=B0=20?= =?UTF-8?q?=D0=BE=D1=81=D0=BD=D0=BE=D0=B2=D0=B5=20=D0=B8=D0=BD=D1=82=D0=B5?= =?UTF-8?q?=D1=80=D1=84=D0=B5=D0=B9=D1=81=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/org/example/GenerateExample.java | 10 +------ .../generator/FromInterfaceGenerator.java | 29 +++++++++++++++++++ .../java/org/example/generator/Generator.java | 9 ++++-- 3 files changed, 36 insertions(+), 12 deletions(-) create mode 100644 src/main/java/org/example/generator/FromInterfaceGenerator.java diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index 1145eb7..f238aba 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -9,20 +9,12 @@ public static void main(String[] args) { var gen = new Generator(); try { int depth = 0; - Object generated = gen.generateValueOfType(org.example.classes.BinaryTreeNode.class, depth); + Object generated = gen.generateValueOfType(org.example.classes.Shape.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/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 d4b2e31..d26b386 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -16,13 +16,15 @@ public class Generator { 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(Class clazz, int depth) throws InvocationTargetException, InstantiationException, IllegalAccessException, - NoSuchMethodException + NoSuchMethodException, + ClassNotFoundException { if (depth > MAX_DEPTH) { return null; @@ -50,7 +52,7 @@ public Object generateValueOfType(Class clazz, int depth) throws return arr[random.nextInt(arr.length)]; } if (clazz.isInterface()) { - return null; + return fromInterfaceGenerator.generate(clazz); } Object generatedType = generateType(clazz, depth+1); return generatedType; @@ -60,7 +62,8 @@ private Object generateType(Class clazz, int depth) throws InvocationTargetException, InstantiationException, IllegalAccessException, - NoSuchMethodException + NoSuchMethodException, + ClassNotFoundException { Constructor constructor = clazz.getDeclaredConstructors()[0]; boolean annotation = clazz.isAnnotationPresent(Generatable.class); From bec05e589ec1b5b9d6c9d4590e1af5e146428f57 Mon Sep 17 00:00:00 2001 From: Timofey Ivankov Date: Sun, 9 Nov 2025 18:12:45 +0300 Subject: [PATCH 21/21] =?UTF-8?q?=D0=B4=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8?= =?UTF-8?q?=D0=BB=20=D0=B3=D0=B5=D0=BD=D0=B5=D1=80=D0=B0=D1=86=D0=B8=D1=8E?= =?UTF-8?q?=20=D0=B4=D0=B6=D0=B5=D0=BD=D0=B5=D1=80=D0=B8=D0=BA=20=D1=82?= =?UTF-8?q?=D0=B0=D0=B9=D0=BF=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/org/example/GenerateExample.java | 10 +- .../java/org/example/generator/Generator.java | 96 ++++++++++++------- 2 files changed, 68 insertions(+), 38 deletions(-) diff --git a/src/main/java/org/example/GenerateExample.java b/src/main/java/org/example/GenerateExample.java index f238aba..5320ffb 100644 --- a/src/main/java/org/example/GenerateExample.java +++ b/src/main/java/org/example/GenerateExample.java @@ -9,12 +9,20 @@ public static void main(String[] args) { var gen = new Generator(); try { int depth = 0; - Object generated = gen.generateValueOfType(org.example.classes.Shape.class, depth); + 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/generator/Generator.java b/src/main/java/org/example/generator/Generator.java index d26b386..42e7fc1 100644 --- a/src/main/java/org/example/generator/Generator.java +++ b/src/main/java/org/example/generator/Generator.java @@ -19,7 +19,7 @@ public class Generator { private final FromInterfaceGenerator fromInterfaceGenerator = new FromInterfaceGenerator(); private static final int MAX_DEPTH = 10; - public Object generateValueOfType(Class clazz, int depth) throws + public Object generateValueOfType(Type type, int depth) throws InvocationTargetException, InstantiationException, IllegalAccessException, @@ -29,33 +29,54 @@ public Object generateValueOfType(Class clazz, int depth) throws if (depth > MAX_DEPTH) { return null; } - 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; - } - 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 (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; + + 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 (clazz.isInterface()) { - return fromInterfaceGenerator.generate(clazz); + + 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); } - Object generatedType = generateType(clazz, depth+1); - return generatedType; + throw new IllegalArgumentException("Unsupported type: " + type); } private Object generateType(Class clazz, int depth) throws @@ -66,18 +87,19 @@ private Object generateType(Class clazz, int depth) throws ClassNotFoundException { Constructor constructor = clazz.getDeclaredConstructors()[0]; - boolean annotation = clazz.isAnnotationPresent(Generatable.class); - if (annotation) { - Class[] paramTypes = constructor.getParameterTypes(); - Object[] params = new Object[paramTypes.length]; - for (int i = 0; i < paramTypes.length; i++) { - params[i] = generateValueOfType(paramTypes[i], depth+1); - } - constructor.setAccessible(true); - Object instance = constructor.newInstance(params); - return instance; - } else { + + 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); } }