From c1e38740afa0104fdfce3c69cf00c2805fb34bae Mon Sep 17 00:00:00 2001 From: Andrey Cheboksarov <37665782+0xaa4eb@users.noreply.github.com> Date: Sat, 6 Jul 2024 17:11:09 +0400 Subject: [PATCH] Code analysis issues 2 (#139) --- .../java/com/ulyp/agent/AgentContext.java | 2 - .../java/com/ulyp/agent/log/OutputChoice.java | 3 + .../java/com/ulyp/agent/log/SimpleLogger.java | 1 - .../agent/log/SimpleLoggerConfiguration.java | 36 +++--- .../ulyp/agent/log/SimpleLoggerFactory.java | 3 + .../policy/FileBasedStartRecordingPolicy.java | 120 ------------------ .../agent/queue/QueueBatchEventProcessor.java | 6 +- .../agent/queue/disruptor/WorkProcessor.java | 6 +- .../agent/tests/concurrent/classes/X0.java | 14 +- .../agent/tests/concurrent/classes/X1.java | 14 +- .../agent/tests/concurrent/classes/X10.java | 14 +- .../agent/tests/concurrent/classes/X100.java | 14 +- .../agent/tests/concurrent/classes/X11.java | 14 +- .../agent/tests/concurrent/classes/X12.java | 14 +- .../agent/tests/concurrent/classes/X13.java | 14 +- .../agent/tests/concurrent/classes/X14.java | 14 +- .../agent/tests/concurrent/classes/X15.java | 14 +- .../agent/tests/concurrent/classes/X16.java | 14 +- .../agent/tests/concurrent/classes/X17.java | 14 +- .../agent/tests/concurrent/classes/X18.java | 14 +- .../agent/tests/concurrent/classes/X19.java | 14 +- .../agent/tests/concurrent/classes/X2.java | 14 +- .../agent/tests/concurrent/classes/X20.java | 14 +- .../agent/tests/concurrent/classes/X21.java | 14 +- .../agent/tests/concurrent/classes/X22.java | 14 +- .../agent/tests/concurrent/classes/X23.java | 14 +- .../agent/tests/concurrent/classes/X24.java | 14 +- .../agent/tests/concurrent/classes/X25.java | 14 +- .../agent/tests/concurrent/classes/X26.java | 14 +- .../agent/tests/concurrent/classes/X27.java | 14 +- .../agent/tests/concurrent/classes/X28.java | 14 +- .../agent/tests/concurrent/classes/X29.java | 14 +- .../agent/tests/concurrent/classes/X3.java | 14 +- .../agent/tests/concurrent/classes/X30.java | 14 +- .../agent/tests/concurrent/classes/X31.java | 14 +- .../agent/tests/concurrent/classes/X32.java | 14 +- .../agent/tests/concurrent/classes/X33.java | 14 +- .../agent/tests/concurrent/classes/X34.java | 14 +- .../agent/tests/concurrent/classes/X35.java | 14 +- .../agent/tests/concurrent/classes/X36.java | 14 +- .../agent/tests/concurrent/classes/X37.java | 14 +- .../agent/tests/concurrent/classes/X38.java | 14 +- .../agent/tests/concurrent/classes/X39.java | 14 +- .../agent/tests/concurrent/classes/X4.java | 14 +- .../agent/tests/concurrent/classes/X40.java | 14 +- .../agent/tests/concurrent/classes/X41.java | 14 +- .../agent/tests/concurrent/classes/X42.java | 14 +- .../agent/tests/concurrent/classes/X43.java | 14 +- .../agent/tests/concurrent/classes/X44.java | 14 +- .../agent/tests/concurrent/classes/X45.java | 14 +- .../agent/tests/concurrent/classes/X46.java | 14 +- .../agent/tests/concurrent/classes/X47.java | 14 +- .../agent/tests/concurrent/classes/X48.java | 14 +- .../agent/tests/concurrent/classes/X49.java | 14 +- .../agent/tests/concurrent/classes/X5.java | 8 +- .../agent/tests/concurrent/classes/X50.java | 14 +- .../agent/tests/concurrent/classes/X51.java | 14 +- .../agent/tests/concurrent/classes/X52.java | 14 +- .../agent/tests/concurrent/classes/X53.java | 14 +- .../agent/tests/concurrent/classes/X54.java | 14 +- .../agent/tests/concurrent/classes/X55.java | 14 +- .../agent/tests/concurrent/classes/X56.java | 14 +- .../agent/tests/concurrent/classes/X57.java | 14 +- .../agent/tests/concurrent/classes/X58.java | 14 +- .../agent/tests/concurrent/classes/X59.java | 14 +- .../agent/tests/concurrent/classes/X6.java | 14 +- .../agent/tests/concurrent/classes/X60.java | 14 +- .../agent/tests/concurrent/classes/X61.java | 14 +- .../agent/tests/concurrent/classes/X62.java | 14 +- .../agent/tests/concurrent/classes/X63.java | 14 +- .../agent/tests/concurrent/classes/X64.java | 14 +- .../agent/tests/concurrent/classes/X65.java | 14 +- .../agent/tests/concurrent/classes/X66.java | 14 +- .../agent/tests/concurrent/classes/X67.java | 14 +- .../agent/tests/concurrent/classes/X68.java | 14 +- .../agent/tests/concurrent/classes/X69.java | 14 +- .../agent/tests/concurrent/classes/X7.java | 14 +- .../agent/tests/concurrent/classes/X70.java | 14 +- .../agent/tests/concurrent/classes/X71.java | 14 +- .../agent/tests/concurrent/classes/X72.java | 14 +- .../agent/tests/concurrent/classes/X73.java | 14 +- .../agent/tests/concurrent/classes/X74.java | 14 +- .../agent/tests/concurrent/classes/X75.java | 14 +- .../agent/tests/concurrent/classes/X76.java | 14 +- .../agent/tests/concurrent/classes/X77.java | 14 +- .../agent/tests/concurrent/classes/X78.java | 14 +- .../agent/tests/concurrent/classes/X79.java | 14 +- .../agent/tests/concurrent/classes/X8.java | 14 +- .../agent/tests/concurrent/classes/X80.java | 14 +- .../agent/tests/concurrent/classes/X81.java | 14 +- .../agent/tests/concurrent/classes/X82.java | 14 +- .../agent/tests/concurrent/classes/X83.java | 14 +- .../agent/tests/concurrent/classes/X84.java | 14 +- .../agent/tests/concurrent/classes/X85.java | 14 +- .../agent/tests/concurrent/classes/X86.java | 14 +- .../agent/tests/concurrent/classes/X87.java | 14 +- .../agent/tests/concurrent/classes/X88.java | 14 +- .../agent/tests/concurrent/classes/X89.java | 14 +- .../agent/tests/concurrent/classes/X9.java | 14 +- .../agent/tests/concurrent/classes/X90.java | 14 +- .../agent/tests/concurrent/classes/X91.java | 14 +- .../agent/tests/concurrent/classes/X92.java | 14 +- .../agent/tests/concurrent/classes/X93.java | 14 +- .../agent/tests/concurrent/classes/X94.java | 14 +- .../agent/tests/concurrent/classes/X95.java | 14 +- .../agent/tests/concurrent/classes/X96.java | 14 +- .../agent/tests/concurrent/classes/X97.java | 14 +- .../agent/tests/concurrent/classes/X98.java | 14 +- .../agent/tests/concurrent/classes/X99.java | 14 +- 109 files changed, 731 insertions(+), 854 deletions(-) delete mode 100644 ulyp-agent-core/src/main/java/com/ulyp/agent/policy/FileBasedStartRecordingPolicy.java diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/AgentContext.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/AgentContext.java index ee6441f2..de694596 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/AgentContext.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/AgentContext.java @@ -94,8 +94,6 @@ private static OverridableRecordingPolicy initializePolicy(Settings settings) { policy = new DelayBasedRecordingPolicy(Duration.ofSeconds(Integer.parseInt(value.replace("delay:", "")))); } else if (value.equals("api")) { policy = new DisabledRecordingPolicy(); - } else if (value.startsWith("file:")) { - policy = new FileBasedStartRecordingPolicy(Paths.get(value.replace("file:", ""))); } else { throw new IllegalArgumentException("Unsupported recording policy: " + value); } diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/OutputChoice.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/OutputChoice.java index 2b7bfa09..003aba50 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/OutputChoice.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/OutputChoice.java @@ -2,6 +2,9 @@ import java.io.PrintStream; +/** + * Forked from slf4j-simple + */ class OutputChoice { enum OutputChoiceType { diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLogger.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLogger.java index aafa6521..5c430810 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLogger.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLogger.java @@ -35,7 +35,6 @@ import com.ulyp.agent.AgentContext; import com.ulyp.agent.RecorderInstance; - /** * Forked from slf4j-simple * diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerConfiguration.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerConfiguration.java index 4e446168..e75b8973 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerConfiguration.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerConfiguration.java @@ -12,43 +12,37 @@ import org.slf4j.helpers.Util; +/** + * Forked from slf4j-simple + */ public class SimpleLoggerConfiguration { private static final String CONFIGURATION_FILE = "simplelogger.properties"; - static int DEFAULT_LOG_LEVEL_DEFAULT = SimpleLogger.LOG_LEVEL_INFO; - int defaultLogLevel = DEFAULT_LOG_LEVEL_DEFAULT; - + private static final boolean SHOW_THREAD_NAME_DEFAULT = true; private static final boolean SHOW_DATE_TIME_DEFAULT = false; - boolean showDateTime = SHOW_DATE_TIME_DEFAULT; - private static final String DATE_TIME_FORMAT_STR_DEFAULT = null; private static String dateTimeFormatStr = DATE_TIME_FORMAT_STR_DEFAULT; + private static int DEFAULT_LOG_LEVEL_DEFAULT = SimpleLogger.LOG_LEVEL_INFO; + private final static boolean SHOW_LOG_NAME_DEFAULT = true; + private static final boolean SHOW_SHORT_LOG_NAME_DEFAULT = false; + private static final boolean LEVEL_IN_BRACKETS_DEFAULT = false; + private static String LOG_FILE_DEFAULT = "System.err"; + private static final boolean CACHE_OUTPUT_STREAM_DEFAULT = false; + private static final String WARN_LEVELS_STRING_DEFAULT = "WARN"; + int defaultLogLevel = DEFAULT_LOG_LEVEL_DEFAULT; + boolean showDateTime = SHOW_DATE_TIME_DEFAULT; DateFormat dateFormatter = null; - - private static final boolean SHOW_THREAD_NAME_DEFAULT = true; boolean showThreadName = SHOW_THREAD_NAME_DEFAULT; - - final static boolean SHOW_LOG_NAME_DEFAULT = true; boolean showLogName = SHOW_LOG_NAME_DEFAULT; - - private static final boolean SHOW_SHORT_LOG_NAME_DEFAULT = false; boolean showShortLogName = SHOW_SHORT_LOG_NAME_DEFAULT; - - private static final boolean LEVEL_IN_BRACKETS_DEFAULT = false; boolean levelInBrackets = LEVEL_IN_BRACKETS_DEFAULT; - - private static String LOG_FILE_DEFAULT = "System.err"; private String logFile = LOG_FILE_DEFAULT; OutputChoice outputChoice = null; - - private static final boolean CACHE_OUTPUT_STREAM_DEFAULT = false; - private boolean cacheOutputStream = CACHE_OUTPUT_STREAM_DEFAULT; - - private static final String WARN_LEVELS_STRING_DEFAULT = "WARN"; String warnLevelString = WARN_LEVELS_STRING_DEFAULT; + private boolean cacheOutputStream = CACHE_OUTPUT_STREAM_DEFAULT; private final Properties properties = new Properties(); void init() { @@ -122,7 +116,7 @@ String getStringProperty(String name) { try { prop = System.getProperty(name); } catch (SecurityException e) { - ; // Ignore + // Ignore } return (prop == null) ? properties.getProperty(name) : prop; } diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerFactory.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerFactory.java index fd2ad44a..120474e2 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerFactory.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/log/SimpleLoggerFactory.java @@ -31,6 +31,9 @@ import org.slf4j.ILoggerFactory; import org.slf4j.Logger; +/** + * Forked from slf4j-simple + */ public class SimpleLoggerFactory implements ILoggerFactory { ConcurrentMap loggerMap; diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/policy/FileBasedStartRecordingPolicy.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/policy/FileBasedStartRecordingPolicy.java deleted file mode 100644 index fd520e3f..00000000 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/policy/FileBasedStartRecordingPolicy.java +++ /dev/null @@ -1,120 +0,0 @@ -package com.ulyp.agent.policy; - -import com.ulyp.core.util.NamedThreadFactory; -import lombok.extern.slf4j.Slf4j; - -import java.io.*; -import java.nio.charset.StandardCharsets; -import java.nio.file.Path; -import java.time.Duration; -import java.util.concurrent.Executors; -import java.util.concurrent.ScheduledExecutorService; -import java.util.concurrent.TimeUnit; - -/** - * File based start recording policy. The file has the value stored which could be either 0 or 1. - * Initially it has value 0, which means no recording can start at the moment. A user may write 1 - * to file - */ -@Slf4j -public class FileBasedStartRecordingPolicy implements StartRecordingPolicy { - - private static final Duration FILE_POLL_INTERVAL = Duration.ofSeconds(1); - private static final char RECORDING_ENABLED_VALUE = '1'; - private static final char RECORDING_DISABLED_VALUE = '0'; - - private final Path file; - private volatile boolean recordingCanStart = false; - - public FileBasedStartRecordingPolicy(Path file) { - this.file = file; - if (!file.toFile().exists()) { - writeToFile('0'); - } - checkInitialValue(); - - // No need to close - ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor( - NamedThreadFactory.builder() - .name("Ulyp-file-" + file + "-monitor") - .daemon(true) - .build() - ); - scheduledExecutorService.scheduleAtFixedRate( - this::checkFileContent, - 0, - FILE_POLL_INTERVAL.toMillis(), - TimeUnit.MILLISECONDS - ); - } - - private void writeToFile(char value) { - try (FileOutputStream outputStream = new FileOutputStream(file.toFile())) { - outputStream.write(value); - } catch (IOException e) { - throw new RuntimeException("Could not write to file " + file, e); - } - } - - private void checkInitialValue() { - try (FileInputStream fileInputStream = new FileInputStream(file.toFile())) { - byte[] buf = new byte[1]; - - int bytesRead = fileInputStream.read(buf); - - if (bytesRead == 1) { - char charValue = new String(buf, StandardCharsets.US_ASCII).charAt(0); - boolean canStartRecordingValue = charValue == RECORDING_ENABLED_VALUE; - if (canStartRecordingValue) { - log.info("Initial value in file {} is {}, recording can start any moment", file, charValue); - this.recordingCanStart = true; - } else { - log.info("Initial value in file " + file + " is " + charValue + ", recording is disabled until content of file is changed"); - this.recordingCanStart = false; - } - } else { - throw new RuntimeException("Could not read one byte from file " + file); - } - } catch (IOException ioe) { - // ignored - log.debug("Error while checking file {}", file, ioe); - } - } - - private void checkFileContent() { - try (FileInputStream fileInputStream = new FileInputStream(file.toFile())) { - byte[] buf = new byte[1]; - - int bytesRead = fileInputStream.read(buf); - - if (bytesRead == 1) { - boolean canStartRecordingValue = new String(buf, StandardCharsets.US_ASCII).charAt(0) == RECORDING_ENABLED_VALUE; - tryUpdateFlag(canStartRecordingValue); - } - } catch (IOException ioe) { - // ignored - log.debug("Error while checking file {}", file, ioe); - } - } - - private void tryUpdateFlag(boolean canStartRecordingValue) { - if (!this.canStartRecording() && canStartRecordingValue) { - log.info("Recording is enabled since value in file {} is 1", this.file); - this.recordingCanStart = true; - } - if (this.canStartRecording() && !canStartRecordingValue) { - log.info("Recording is disabled since value in file {} is 0", this.file); - this.recordingCanStart = false; - } - } - - @Override - public boolean canStartRecording() { - return recordingCanStart; - } - - @Override - public String toString() { - return "Can start recording any time"; - } -} diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/QueueBatchEventProcessor.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/QueueBatchEventProcessor.java index 4baddfdc..e7a4eda4 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/QueueBatchEventProcessor.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/QueueBatchEventProcessor.java @@ -94,12 +94,12 @@ private void processEvents() { sequence.set(availableSequence); } catch (final AlertException ex) { if (status.get() != RUNNING) { - break; + return; } } catch (InterruptedException ie) { Thread.currentThread().interrupt(); - break; - } catch (final Throwable ex) { + return; + } catch (Exception ex) { sequence.set(nextSequence); nextSequence++; } diff --git a/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/disruptor/WorkProcessor.java b/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/disruptor/WorkProcessor.java index 827d2a56..98b9b6c7 100644 --- a/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/disruptor/WorkProcessor.java +++ b/ulyp-agent-core/src/main/java/com/ulyp/agent/queue/disruptor/WorkProcessor.java @@ -102,7 +102,7 @@ public void run() { if (!running.get()) { break; } - } catch (final Throwable ex) { + } catch (Exception ex) { // handle, mark as processed, unless the exception handler threw an exception exceptionHandler.handleEventException(ex, nextSequence, event); processedSequence = true; @@ -128,7 +128,7 @@ private void notifyStart() { if (workHandler instanceof LifecycleAware) { try { ((LifecycleAware) workHandler).onStart(); - } catch (final Throwable ex) { + } catch (Exception ex) { exceptionHandler.handleOnStartException(ex); } } @@ -138,7 +138,7 @@ private void notifyShutdown() { if (workHandler instanceof LifecycleAware) { try { ((LifecycleAware) workHandler).onShutdown(); - } catch (final Throwable ex) { + } catch (Exception ex) { exceptionHandler.handleOnShutdownException(ex); } } diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X0.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X0.java index 96aa1ecc..de0efbbf 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X0.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X0.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X0 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X1.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X1.java index 66f796f6..f0646e92 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X1.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X1.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X1 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X10.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X10.java index 29fcce6c..51fa82bb 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X10.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X10.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X10 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X100.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X100.java index bd1b3627..3d2b3b4e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X100.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X100.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X100 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X11.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X11.java index 080b53c5..4620f69c 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X11.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X11.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X11 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X12.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X12.java index 8947c104..56f6e3a2 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X12.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X12.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X12 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X13.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X13.java index 4b478d63..fb9c8302 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X13.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X13.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X13 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X14.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X14.java index 76aba2f0..8aaed47a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X14.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X14.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X14 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X15.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X15.java index dac3cd1d..e0686e4e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X15.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X15.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X15 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X16.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X16.java index 5a35f945..e4a158a0 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X16.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X16.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X16 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X17.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X17.java index 4a33009b..7d167436 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X17.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X17.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X17 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X18.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X18.java index ee9607e5..17f91cc6 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X18.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X18.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X18 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X19.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X19.java index 899cf8c3..56eb19e1 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X19.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X19.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X19 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X2.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X2.java index 0930ba4f..059b149b 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X2.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X2.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X2 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X20.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X20.java index 06ce3ebd..436ea5eb 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X20.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X20.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X20 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X21.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X21.java index 7317dccb..e9616596 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X21.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X21.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X21 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X22.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X22.java index 02947426..1ff480d1 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X22.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X22.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X22 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X23.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X23.java index 03541fdc..5c568696 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X23.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X23.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X23 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X24.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X24.java index f72aca66..e66a191a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X24.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X24.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X24 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X25.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X25.java index 94d6dcfc..9a7674e8 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X25.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X25.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X25 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X26.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X26.java index e2379bb9..e0c869c2 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X26.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X26.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X26 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X27.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X27.java index a97bf7d5..9018d813 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X27.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X27.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X27 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X28.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X28.java index fe5926aa..738713c8 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X28.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X28.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X28 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X29.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X29.java index e740712d..f6164966 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X29.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X29.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X29 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X3.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X3.java index ae451c70..03f48808 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X3.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X3.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X3 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X30.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X30.java index 7ca01ad0..ac141545 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X30.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X30.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X30 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X31.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X31.java index a5384210..3e607988 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X31.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X31.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X31 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X32.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X32.java index 8c739a0a..f5fa3692 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X32.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X32.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X32 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X33.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X33.java index 5cca3989..d1721851 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X33.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X33.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X33 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X34.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X34.java index d23cd86c..98087d0a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X34.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X34.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X34 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X35.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X35.java index 95a15a36..f359e7fc 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X35.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X35.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X35 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X36.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X36.java index 1739b369..ce3737f5 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X36.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X36.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X36 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X37.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X37.java index 6a41bdfa..f91bb00a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X37.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X37.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X37 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X38.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X38.java index 4f508833..94bab9a5 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X38.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X38.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X38 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X39.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X39.java index 0c49ce28..344b3a74 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X39.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X39.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X39 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X4.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X4.java index 95db4d03..8749bb1e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X4.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X4.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X4 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X40.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X40.java index 2ff6669a..e197ac39 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X40.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X40.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X40 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X41.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X41.java index 9c16b9b7..7ed4ad34 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X41.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X41.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X41 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X42.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X42.java index 98ef476e..8a602f5a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X42.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X42.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X42 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X43.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X43.java index 14443037..a39fc96a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X43.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X43.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X43 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X44.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X44.java index 63eab760..3077e591 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X44.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X44.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X44 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X45.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X45.java index 3a6a714a..d6a7266c 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X45.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X45.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X45 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X46.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X46.java index ac614f2f..6bf5c59c 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X46.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X46.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X46 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X47.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X47.java index 88a6ffbd..a066f212 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X47.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X47.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X47 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X48.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X48.java index 10faec80..194db6f3 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X48.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X48.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X48 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X49.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X49.java index 86ed0def..d5a44ece 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X49.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X49.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X49 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X5.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X5.java index 9bc1c84f..7e19eafd 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X5.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X5.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X5 { public int m1(int a, int b, int c) { @@ -30,17 +30,17 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X50.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X50.java index 4a458315..4f510b1e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X50.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X50.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X50 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X51.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X51.java index 06e4c938..f3e39e6e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X51.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X51.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X51 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X52.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X52.java index 5eeda4d4..25723d24 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X52.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X52.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X52 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X53.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X53.java index a11e2917..0f1e742c 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X53.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X53.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X53 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X54.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X54.java index d46db831..b2ab0e9f 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X54.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X54.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X54 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X55.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X55.java index 54503b23..006297bd 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X55.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X55.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X55 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X56.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X56.java index ac81a425..4f2b8e2e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X56.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X56.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X56 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X57.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X57.java index 66f8c330..a54223f7 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X57.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X57.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X57 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X58.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X58.java index ce197833..621b5e8c 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X58.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X58.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X58 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X59.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X59.java index 7d6567e4..72a1e303 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X59.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X59.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X59 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X6.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X6.java index e4ed9e4a..6e0e9f51 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X6.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X6.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X6 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X60.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X60.java index 2b352e5f..681bc63c 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X60.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X60.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X60 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X61.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X61.java index bac81092..00ebf6de 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X61.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X61.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X61 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X62.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X62.java index 18936570..9e95ffd5 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X62.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X62.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X62 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X63.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X63.java index d3695de8..b7cd1102 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X63.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X63.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X63 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X64.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X64.java index 8a099217..7dfea2db 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X64.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X64.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X64 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X65.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X65.java index 5d10ae2c..86b266e3 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X65.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X65.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X65 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X66.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X66.java index 28a45fc2..e8c0b5bf 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X66.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X66.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X66 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X67.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X67.java index 5dbf0f06..7fc5f479 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X67.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X67.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X67 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X68.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X68.java index 023c819e..37ec73fb 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X68.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X68.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X68 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X69.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X69.java index 575b91f8..db9e0b17 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X69.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X69.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X69 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X7.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X7.java index 8e62cb82..3b5be615 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X7.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X7.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X7 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X70.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X70.java index 3e3f02f9..740db868 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X70.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X70.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X70 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X71.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X71.java index e7050c7c..0ab9f6a4 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X71.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X71.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X71 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X72.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X72.java index bf4fa5f4..76b95c7a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X72.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X72.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X72 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X73.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X73.java index 0eacbbfa..1470ffce 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X73.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X73.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X73 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X74.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X74.java index a50c5ff8..37481bd0 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X74.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X74.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X74 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X75.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X75.java index fa2f924f..8042b782 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X75.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X75.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X75 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X76.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X76.java index 1b922bd6..2ed73c64 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X76.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X76.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X76 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X77.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X77.java index f91e099c..781844e1 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X77.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X77.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X77 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X78.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X78.java index 9b01c221..dc1ac7ae 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X78.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X78.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X78 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X79.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X79.java index 63ecf48e..cca4181d 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X79.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X79.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X79 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X8.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X8.java index 604090c0..cb85813b 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X8.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X8.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X8 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X80.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X80.java index 3b7f1a7f..46743c77 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X80.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X80.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X80 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X81.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X81.java index 4cc3b3fe..eae60c25 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X81.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X81.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X81 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X82.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X82.java index 18f34571..3a267da9 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X82.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X82.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X82 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X83.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X83.java index d62f3002..aa31204b 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X83.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X83.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X83 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X84.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X84.java index 47a2a6a6..43a22b3a 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X84.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X84.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X84 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X85.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X85.java index 9e5f6406..4c6bddfb 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X85.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X85.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X85 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X86.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X86.java index 021c53a9..4f32f708 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X86.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X86.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X86 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X87.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X87.java index ecc8047a..25f16677 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X87.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X87.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X87 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X88.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X88.java index 0e3da886..5f528854 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X88.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X88.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X88 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X89.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X89.java index c8cc2fbe..a56cba98 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X89.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X89.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X89 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X9.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X9.java index 28bd58f5..6c35afd4 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X9.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X9.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X9 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X90.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X90.java index 59438f14..52bd7564 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X90.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X90.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X90 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X91.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X91.java index e9916cd4..385d9d63 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X91.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X91.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X91 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X92.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X92.java index 2e513ab1..ecd31abb 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X92.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X92.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X92 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X93.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X93.java index 24820165..133c9386 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X93.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X93.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X93 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X94.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X94.java index 29c6f4a2..30e6d664 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X94.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X94.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X94 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X95.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X95.java index 82c00a73..3e930d6e 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X95.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X95.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X95 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X96.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X96.java index 71e3e9f5..bd4a8c66 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X96.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X96.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X96 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X97.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X97.java index fd9fb0cf..97d32256 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X97.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X97.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X97 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X98.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X98.java index 3dcf3bb7..322e38ff 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X98.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X98.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X98 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() { diff --git a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X99.java b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X99.java index e8278913..905616a4 100644 --- a/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X99.java +++ b/ulyp-agent-tests/src/test/java/com/agent/tests/concurrent/classes/X99.java @@ -1,6 +1,6 @@ package com.agent.tests.concurrent.classes; -// Automatically generated and only used for instrumentation tests +// Automatically generated and only used for instrumentation tests. The code is meaningless and has only single purpose - code analysis should not hate it too much @SuppressWarnings("unused") public class X99 { public int m1(int a, int b, int c) { @@ -30,27 +30,27 @@ public int m5(short a, short b, short c) { public String m8(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m9(Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return y + z + suffix; + return x + y + z + suffix; } public String m10(String prefix, Integer x, Long y, Long z, String suffix) { System.out.println("1"); - return prefix + y + z + suffix; + return prefix + x + y + z + suffix; } - public String m11(Integer x, Long y, Long z) { + public String m11(Float x, Double y, Double z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z + x); } public String m12(Integer x, Long y, Long z) { System.out.println("1"); - return String.valueOf(y + z); + return String.valueOf(y + z) + x; } public void m13() {