Update app.py

app.py

@@ -19,103 +19,302 @@ CODE_SNIPPETS = [
 "import java.util.Random; public static int generateRandomNumber() { return new Random().nextInt(); }",
 "public static boolean isEven(int number) { return number % 2 == 0; }",
 "public static int stringLength(String str) { return str.length(); }",
-"import java.time.LocalDate; public static LocalDate getCurrentDate() { return LocalDate.now(); }",
+"import java.time.LocalDate; public static String getCurrentDate() { return LocalDate.now().toString(); }",
 "import java.io.File; public static boolean fileExists(String path) { return new File(path).exists(); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static String readFileContent(String path) throws Exception { return new String(Files.readAllBytes(Paths.get(path))); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static void writeToFile(String path, String content) throws Exception { Files.write(Paths.get(path), content.getBytes()); }",
-"import java.time.LocalTime; public static LocalTime getCurrentTime() { return LocalTime.now(); }",
+"import java.time.LocalTime; public static String getCurrentTime() { return LocalTime.now().toString(); }",
 "public static String toUpperCase(String str) { return str.toUpperCase(); }",
 "public static String toLowerCase(String str) { return str.toLowerCase(); }",
 "public static String reverseString(String str) { return new StringBuilder(str).reverse().toString(); }",
-"public static int countListElements(List<?> list) { return list.size(); }",
-"public static int findMax(List<Integer> list) { return Collections.max(list); }",
-"public static int findMin(List<Integer> list) { return Collections.min(list); }",
+"public static int listSize(List<?> list) { return list.size(); }",
+"public static int maxInList(List<Integer> list) { return Collections.max(list); }",
+"public static int minInList(List<Integer> list) { return Collections.min(list); }",
 "public static List<Integer> sortList(List<Integer> list) { Collections.sort(list); return list; }",
-"public static List<?> mergeLists(List<?> list1, List<?> list2) { List<Object> mergedList = new ArrayList<>(list1); mergedList.addAll(list2); return mergedList; }",
-"public static void removeElement(List<?> list, Object element) { list.remove(element); }",
+"public static List<?> mergeLists(List<?> list1, List<?> list2) { List<Object> merged = new ArrayList<>(list1); merged.addAll(list2); return merged; }",
+"public static List<?> removeElement(List<?> list, Object element) { list.remove(element); return list; }",
 "public static boolean isListEmpty(List<?> list) { return list.isEmpty(); }",
-"public static int countCharOccurrences(String str, char ch) { return (int) str.chars().filter(c -> c == ch).count(); }",
+"public static int countCharInString(String str, char ch) { return (int) str.chars().filter(c -> c == ch).count(); }",
 "public static boolean containsSubstring(String str, String sub) { return str.contains(sub); }",
-"public static String numberToString(int number) { return Integer.toString(number); }",
-"public static int stringToNumber(String str) { return Integer.parseInt(str); }",
-"public static boolean isNumeric(String str) { return str.matches(\"\\\\d+\"); }",
-"public static int getElementIndex(List<?> list, Object element) { return list.indexOf(element); }",
+"public static String intToString(int number) { return Integer.toString(number); }",
+"public static int stringToInt(String str) { return Integer.parseInt(str); }",
+"public static boolean isNumeric(String str) { return str.matches(\"-?\\\\d+(\\\\.\\\\d+)?\"); }",
+"public static int indexOfElement(List<?> list, Object element) { return list.indexOf(element); }",
 "public static void clearList(List<?> list) { list.clear(); }",
-"public static void reverseList(List<?> list) { Collections.reverse(list); }",
-"public static List<?> removeDuplicates(List<?> list) { return new ArrayList<>(new HashSet<>(list)); }",
+"public static List<?> reverseList(List<?> list) { Collections.reverse(list); return list; }",
+"public static List<?> removeDuplicates(List<?> list) { return new ArrayList<>(new LinkedHashSet<>(list)); }",
 "public static boolean isInList(List<?> list, Object element) { return list.contains(element); }",
-"public static Map<Object, Object> createDictionary() { return new HashMap<>(); }",
-"public static void addToDictionary(Map<Object, Object> dict, Object key, Object value) { dict.put(key, value); }",
-"public static void removeFromDictionary(Map<Object, Object> dict, Object key) { dict.remove(key); }",
-"public static Set<Object> getDictionaryKeys(Map<Object, Object> dict) { return dict.keySet(); }",
-"public static Collection<Object> getDictionaryValues(Map<Object, Object> dict) { return dict.values(); }",
-"public static Map<Object, Object> mergeDictionaries(Map<Object, Object> dict1, Map<Object, Object> dict2) { Map<Object, Object> mergedDict = new HashMap<>(dict1); mergedDict.putAll(dict2); return mergedDict; }",
-"public static boolean isDictionaryEmpty(Map<Object, Object> dict) { return dict.isEmpty(); }",
-"public static Object getDictionaryValue(Map<Object, Object> dict, Object key) { return dict.get(key); }",
-"public static boolean keyExistsInDictionary(Map<Object, Object> dict, Object key) { return dict.containsKey(key); }",
-"public static void clearDictionary(Map<Object, Object> dict) { dict.clear(); }",
-"import java.io.BufferedReader; import java.io.FileReader; public static int countFileLines(String path) throws Exception { return (int) new BufferedReader(new FileReader(path)).lines().count(); }",
+"public static Map<?, ?> createDictionary() { return new HashMap<>(); }",
+"public static void addToDictionary(Map<?, ?> map, Object key, Object value) { ((Map<Object, Object>) map).put(key, value); }",
+"public static void removeFromDictionary(Map<?, ?> map, Object key) { map.remove(key); }",
+"public static Set<?> getDictionaryKeys(Map<?, ?> map) { return map.keySet(); }",
+"public static Collection<?> getDictionaryValues(Map<?, ?> map) { return map.values(); }",
+"public static Map<?, ?> mergeDictionaries(Map<?, ?> map1, Map<?, ?> map2) { Map<Object, Object> merged = new HashMap<>(map1); merged.putAll(map2); return merged; }",
+"public static boolean isDictionaryEmpty(Map<?, ?> map) { return map.isEmpty(); }",
+"public static Object getDictionaryValue(Map<?, ?> map, Object key) { return map.get(key); }",
+"public static boolean keyExistsInDictionary(Map<?, ?> map, Object key) { return map.containsKey(key); }",
+"public static void clearDictionary(Map<?, ?> map) { map.clear(); }",
+"public static int countFileLines(String path) throws Exception { return (int) Files.lines(Paths.get(path)).count(); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static void writeListToFile(String path, List<?> list) throws Exception { Files.write(Paths.get(path), list.toString().getBytes()); }",
-"import java.nio.file.Files; import java.nio.file.Paths; public static List<String> readListFromFile(String path) throws Exception { return Files.readAllLines(Paths.get(path)); }",
-"import java.io.BufferedReader; import java.io.FileReader; public static int countFileWords(String path) throws Exception { return new BufferedReader(new FileReader(path)).lines().mapToInt(line -> line.split(\"\\\\s+\").length).sum(); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static List<?> readListFromFile(String path) throws Exception { return Arrays.asList(new String(Files.readAllBytes(Paths.get(path))).split(\",\")); }",
+"public static int countWordsInFile(String path) throws Exception { return (int) Files.lines(Paths.get(path)).flatMap(line -> Arrays.stream(line.split(\"\\\\s+\"))).count(); }",
 "public static boolean isLeapYear(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); }",
-"import java.time.format.DateTimeFormatter; public static String formatTime(LocalTime time, String pattern) { return time.format(DateTimeFormatter.ofPattern(pattern)); }",
-"import java.time.LocalDate; import java.time.temporal.ChronoUnit; public static long daysBetween(LocalDate date1, LocalDate date2) { return ChronoUnit.DAYS.between(date1, date2); }",
+"import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; public static String formatDateTime(LocalDateTime dateTime, String pattern) { return dateTime.format(DateTimeFormatter.ofPattern(pattern)); }",
+"import java.time.LocalDate; import java.time.temporal.ChronoUnit; public static long daysBetweenDates(LocalDate date1, LocalDate date2) { return ChronoUnit.DAYS.between(date1, date2); }",
 "import java.nio.file.Paths; public static String getCurrentWorkingDirectory() { return Paths.get(\"\").toAbsolutePath().toString(); }",
-"import java.io.File; public static List<String> listFilesInDirectory(String path) { return Arrays.asList(new File(path).list()); }",
+"import java.io.File; public static List<String> listFilesInDirectory(String path) { return Arrays.stream(new File(path).listFiles()).map(File::getName).collect(Collectors.toList()); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static void createDirectory(String path) throws Exception { Files.createDirectory(Paths.get(path)); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static void deleteDirectory(String path) throws Exception { Files.delete(Paths.get(path)); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static boolean isFile(String path) { return Files.isRegularFile(Paths.get(path)); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static boolean isDirectory(String path) { return Files.isDirectory(Paths.get(path)); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static long getFileSize(String path) throws Exception { return Files.size(Paths.get(path)); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static void renameFile(String oldPath, String newPath) throws Exception { Files.move(Paths.get(oldPath), Paths.get(newPath)); }",
-"import java.nio.file.Files; import java.nio.file.Paths; public static void copyFile(String sourcePath, String destinationPath) throws Exception { Files.copy(Paths.get(sourcePath), Paths.get(destinationPath)); }",
-"import java.nio.file.Files; import java.nio.file.Paths; public static void moveFile(String sourcePath, String destinationPath) throws Exception { Files.move(Paths.get(sourcePath), Paths.get(destinationPath)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void copyFile(String source, String destination) throws Exception { Files.copy(Paths.get(source), Paths.get(destination)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void moveFile(String source, String destination) throws Exception { Files.move(Paths.get(source), Paths.get(destination)); }",
 "import java.nio.file.Files; import java.nio.file.Paths; public static void deleteFile(String path) throws Exception { Files.delete(Paths.get(path)); }",
-"public static String getEnvVariable(String name) { return System.getenv(name); }",
-"public static void setEnvVariable(String name, String value) { System.setProperty(name, value); }",
+"public static String getEnvironmentVariable(String name) { return System.getenv(name); }",
+"public static void setEnvironmentVariable(String name, String value) { System.setProperty(name, value); }",
 "import java.awt.Desktop; import java.net.URI; public static void openWebLink(String url) throws Exception { Desktop.getDesktop().browse(new URI(url)); }",
-"import java.net.HttpURLConnection; import java.net.URL; public static String sendGetRequest(String url) throws Exception { HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection(); connection.setRequestMethod(\"GET\"); return new String(connection.getInputStream().readAllBytes()); }",
-"import com.google.gson.JsonParser; public static Object parseJson(String json) { return JsonParser.parseString(json); }",
-"import com.google.gson.Gson; import java.nio.file.Files; import java.nio.file.Paths; public static void writeJsonToFile(String path, Object obj) throws Exception { Files.write(Paths.get(path), new Gson().toJson(obj).getBytes()); }",
-"import com.google.gson.Gson; import java.nio.file.Files; import java.nio.file.Paths; public static Object readJsonFromFile(String path) throws Exception { return new Gson().fromJson(new String(Files.readAllBytes(Paths.get(path))), Object.class); }",
+"import java.net.HttpURLConnection; import java.net.URL; public static String sendGetRequest(String url) throws Exception { HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection(); con.setRequestMethod(\"GET\"); return new String(con.getInputStream().readAllBytes()); }",
+"import com.google.gson.JsonObject; import com.google.gson.JsonParser; public static JsonObject parseJson(String json) { return JsonParser.parseString(json).getAsJsonObject(); }",
+"import com.google.gson.Gson; import java.nio.file.Files; import java.nio.file.Paths; public static void writeJsonToFile(String path, JsonObject json) throws Exception { Files.write(Paths.get(path), new Gson().toJson(json).getBytes()); }",
+"import com.google.gson.JsonObject; import com.google.gson.JsonParser; import java.nio.file.Files; import java.nio.file.Paths; public static JsonObject readJsonFromFile(String path) throws Exception { return JsonParser.parseString(new String(Files.readAllBytes(Paths.get(path)))).getAsJsonObject(); }",
 "public static String listToString(List<?> list) { return list.toString(); }",
 "public static List<String> stringToList(String str) { return Arrays.asList(str.split(\",\")); }",
-"public static String joinWithComma(List<?> list) { return String.join(\",\", list.stream().map(Object::toString).toArray(String[]::new)); }",
-"public static String joinWithNewline(List<?> list) { return String.join(\"\\n\", list.stream().map(Object::toString).toArray(String[]::new)); }",
-"public static String[] splitBySpace(String str) { return str.split(\"\\\\s+\"); }",
-"public static String[] splitByDelimiter(String str, String delimiter) { return str.split(delimiter); }",
-"public static String[] splitIntoChars(String str) { return str.split(\"\"); }",
+"public static String joinWithComma(List<?> list) { return String.join(\",\", list.stream().map(Object::toString).collect(Collectors.toList())); }",
+"public static String joinWithNewline(List<?> list) { return String.join(\"\\n\", list.stream().map(Object::toString).collect(Collectors.toList())); }",
+"public static List<String> splitBySpace(String str) { return Arrays.asList(str.split(\"\\\\s+\")); }",
+"public static List<String> splitByDelimiter(String str, String delimiter) { return Arrays.asList(str.split(delimiter)); }",
+"public static List<String> splitIntoCharacters(String str) { return Arrays.asList(str.split(\"\")); }",
 "public static String replaceInString(String str, String target, String replacement) { return str.replace(target, replacement); }",
 "public static String removeSpaces(String str) { return str.replaceAll(\"\\\\s\", \"\"); }",
 "public static String removePunctuation(String str) { return str.replaceAll(\"[^a-zA-Z0-9]\", \"\"); }",
 "public static boolean isStringEmpty(String str) { return str.isEmpty(); }",
 "public static boolean isPalindrome(String str) { return str.equals(new StringBuilder(str).reverse().toString()); }",
-"import com.opencsv.CSVWriter; import java.io.FileWriter; public static void writeToCsv(String path, List<String[]> data) throws Exception { CSVWriter writer = new CSVWriter(new FileWriter(path)); writer.writeAll(data); writer.close(); }",
-"import com.opencsv.CSVReader; import java.io.FileReader; public static List<String[]> readFromCsv(String path) throws Exception { CSVReader reader = new CSVReader(new FileReader(path)); return reader.readAll(); }",
-"import com.opencsv.CSVReader; import java.io.FileReader; public static int countCsvLines(String path) throws Exception { return readFromCsv(path).size(); }",
-"public static void shuffleList(List<?> list) { Collections.shuffle(list); }",
-"public static Object getRandomElement(List<?> list) { return list.get(new Random().nextInt(list.size())); }",
-"public static List<?> getRandomElements(List<?> list, int count) { Collections.shuffle(list); return list.subList(0, count); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static void writeTextToCsv(String path, List<String> lines) throws Exception { Files.write(Paths.get(path), lines); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static List<String> readCsvFile(String path) throws Exception { return Files.readAllLines(Paths.get(path)); }",
+"import java.nio.file.Files; import java.nio.file.Paths; public static int countCsvLines(String path) throws Exception { return (int) Files.lines(Paths.get(path)).count(); }",
+"public static List<?> shuffleList(List<?> list) { Collections.shuffle(list); return list; }",
+"public static Object pickRandomElement(List<?> list) { return list.get(new Random().nextInt(list.size())); }",
+"public static List<?> pickRandomElements(List<?> list, int count) { Collections.shuffle(list); return list.subList(0, count); }",
 "public static int rollDice() { return new Random().nextInt(6) + 1; }",
 "public static String flipCoin() { return new Random().nextBoolean() ? \"Heads\" : \"Tails\"; }",
-"import java.util.Random; public static String generateRandomPassword(int length) { String chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"; StringBuilder password = new StringBuilder(); for (int i = 0; i < length; i++) { password.append(chars.charAt(new Random().nextInt(chars.length()))); } return password.toString(); }",
-"import java.util.Random; public static String generateRandomColor() { Random random = new Random(); return String.format(\"#%06x\", random.nextInt(0xFFFFFF + 1)); }",
+"import java.util.Random; public static String generateRandomPassword(int length) { String chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\"; StringBuilder sb = new StringBuilder(); for (int i = 0; i < length; i++) { sb.append(chars.charAt(new Random().nextInt(chars.length()))); } return sb.toString(); }",
+"import java.util.Random; public static String generateRandomColor() { Random rand = new Random(); return String.format(\"#%06x\", rand.nextInt(0xFFFFFF)); }",
 "import java.util.UUID; public static String generateUniqueId() { return UUID.randomUUID().toString(); }",
 "public class MyClass {}",
 "MyClass myObject = new MyClass();",
 "public class MyClass { public void myMethod() {} }",
 "public class MyClass { public String myAttribute; }",
-"public class ChildClass extends MyClass {}",
-"public class ChildClass extends MyClass { @Override public void myMethod() {} }",
+"public class ChildClass extends ParentClass {}",
+"public class ChildClass extends ParentClass { @Override public void myMethod() {} }",
 "public class MyClass { public static void myClassMethod() {} }",
 "public class MyClass { public static void myStaticMethod() {} }",
 "public static boolean isInstanceOf(Object obj, Class<?> clazz) { return clazz.isInstance(obj); }",
 "public static Object getAttribute(Object obj, String attribute) throws Exception { return obj.getClass().getDeclaredField(attribute).get(obj); }",
 "public static void setAttribute(Object obj, String attribute, Object value) throws Exception { obj.getClass().getDeclaredField(attribute).set(obj, value); }",
-"public static void deleteAttribute(Object obj, String attribute) throws Exception { obj.getClass().getDeclaredField(attribute).set(obj, null); }"
+"public static void deleteAttribute(Object obj, String attribute) throws Exception { obj.getClass().getDeclaredField(attribute).set(obj, null); }",
+"try { int result = 10 / 0; } catch (Exception e) { System.out.println(e.getMessage()); }",
+"throw new Exception('Custom exception');",
+"String message = e.getMessage();",
+"Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, e);",
+"long startTime = System.currentTimeMillis();",
+"long endTime = System.currentTimeMillis(); long duration = endTime - startTime;",
+"for (int i = 0; i <= 100; i++) { System.out.print('\\rProgress: ' + i + '%'); }",
+"Thread.sleep(1000);",
+"Runnable r = () -> System.out.println('Lambda expression');",
+"List<Integer> squared = Arrays.asList(1, 2, 3).stream().map(x -> x * x).collect(Collectors.toList());",
+"List<Integer> evenNumbers = Arrays.asList(1, 2, 3, 4).stream().filter(x -> x % 2 == 0).collect(Collectors.toList());",
+"int sum = Arrays.asList(1, 2, 3).stream().reduce(0, (a, b) -> a + b);",
+"List<Integer> squares = Arrays.asList(1, 2, 3).stream().map(x -> x * x).collect(Collectors.toList());",
+"Map<String, Integer> map = Arrays.asList('a', 'b').stream().collect(Collectors.toMap(Function.identity(), String::length));",
+"Set<Integer> set = Arrays.asList(1, 2, 3).stream().collect(Collectors.toSet());",
+"Set<Integer> intersection = new HashSet<>(set1); intersection.retainAll(set2);",
+"Set<Integer> union = new HashSet<>(set1); union.addAll(set2);",
+"Set<Integer> difference = new HashSet<>(set1); difference.removeAll(set2);",
+"List<String> listWithoutNull = list.stream().filter(Objects::nonNull).collect(Collectors.toList());",
+"try (BufferedReader br = new BufferedReader(new FileReader('file.txt'))) { } catch (IOException e) { }",
+"if (variable instanceof Integer) { }",
+"boolean bool = Boolean.parseBoolean('true');",
+"if (condition) { }",
+"while (condition) { }",
+"for (String item : list) { }",
+"for (Map.Entry<String, Integer> entry : map.entrySet()) { }",
+"for (char c : 'string'.toCharArray()) { }",
+"break;",
+"continue;",
+"void myFunction() { }",
+"void myFunction(String param = 'default') { }",
+"return new Object[] { value1, value2 };",
+"void myFunction(String... args) { }",
+"void myFunction(Map<String, String> kwargs) { }",
+"long startTime = System.currentTimeMillis(); myFunction(); long endTime = System.currentTimeMillis(); long duration = endTime - startTime;",
+"@Decorator public void myFunction() { }",
+"Map<String, Object> cache = new HashMap<>();",
+"Stream<Integer> stream = Stream.of(1, 2, 3);",
+"yield return value;",
+"int nextValue = generator.next();",
+"Iterator<Integer> iterator = list.iterator();",
+"while (iterator.hasNext()) { int next = iterator.next(); }",
+"for (int i = 0; i < list.size(); i++) { System.out.println(i + ' ' + list.get(i)); }",
+"List<String> combined = Stream.concat(list1.stream(), list2.stream()).collect(Collectors.toList());",
+"Map<String, Integer> map = new HashMap<>(); for (int i = 0; i < keys.size(); i++) { map.put(keys.get(i), values.get(i)); }",
+"boolean equal = list1.equals(list2);",
+"boolean equal = map1.equals(map2);",
+"boolean equal = set1.equals(set2);",
+"Set<Integer> uniqueSet = new HashSet<>(list);",
+"set.clear();",
+"boolean isEmpty = set.isEmpty();",
+"set.add(element);",
+"set.remove(element);",
+"boolean contains = set.contains(element);",
+"int size = set.size();",
+"boolean hasIntersection = !Collections.disjoint(set1, set2);",
+"boolean isSubset = set1.containsAll(set2);",
+"boolean isSubstring = 'hello'.contains('ell');",
+"char firstChar = 'hello'.charAt(0);",
+"char lastChar = 'hello'.charAt('hello'.length() - 1);",
+"boolean isTextFile = fileName.endsWith('.txt');",
+"boolean isImageFile = fileName.endsWith('.jpg') || fileName.endsWith('.png');",
+"long rounded = Math.round(3.14);",
+"long ceil = (long) Math.ceil(3.14);",
+"long floor = (long) Math.floor(3.14);",
+"String formatted = String.format('%.2f', 3.14159);",
+"String randomString = new Random().ints(10, 97, 123).mapToObj(i -> (char) i).collect(StringBuilder::new, StringBuilder::append, StringBuilder::append).toString();",
+"boolean exists = new File('path').exists();",
+"File[] files = new File('path').listFiles();",
+"String extension = fileName.substring(fileName.lastIndexOf('.') + 1);",
+"String fileName = new File('path').getName();",
+"String fullPath = new File('path').getAbsolutePath();",
+"String version = System.getProperty('java.version');",
+"String os = System.getProperty('os.name');",
+"int cores = Runtime.getRuntime().availableProcessors();",
+"long memory = Runtime.getRuntime().totalMemory();",
+"File file = new File('path'); long freeSpace = file.getFreeSpace();",
+"String ip = InetAddress.getLocalHost().getHostAddress();",
+"boolean isConnected = InetAddress.getByName('www.google.com').isReachable(1000);",
+"URL url = new URL('http://example.com/file.txt'); try (InputStream in = url.openStream()) { Files.copy(in, Paths.get('file.txt'), StandardCopyOption.REPLACE_EXISTING); }",
+"HttpURLConnection connection = (HttpURLConnection) new URL('http://example.com').openConnection(); connection.setRequestMethod('POST');",
+"HttpURLConnection connection = (HttpURLConnection) new URL('http://example.com').openConnection(); connection.setRequestMethod('GET'); connection.setRequestProperty('User-Agent', 'Mozilla/5.0');",
+"Document doc = Jsoup.connect('http://example.com').get();",
+"String title = doc.title();",
+"Elements links = doc.select('a[href]');",
+"Elements images = doc.select('img[src]');",
+"Map<String, Integer> wordFrequency = new HashMap<>(); for (String word : text.split(' ')) { wordFrequency.put(word, wordFrequency.getOrDefault(word, 0) + 1); }",
+"Connection.Response loginForm = Jsoup.connect('http://example.com/login').method(Connection.Method.GET).execute(); Map<String, String> cookies = loginForm.cookies(); Document doc = Jsoup.connect('http://example.com/login').data('username', 'user', 'password', 'pass').cookies(cookies).post();",
+"String text = Jsoup.parse(html).text();",
+"Pattern pattern = Pattern.compile('[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}'); Matcher matcher = pattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group()); }",
+"Pattern pattern = Pattern.compile('\\d{3}-\\d{3}-\\d{4}'); Matcher matcher = pattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group()); }",
+"Pattern pattern = Pattern.compile('\\d+'); Matcher matcher = pattern.matcher(text); while (matcher.find()) { System.out.println(matcher.group()); }",
+"String replaced = text.replaceAll('pattern', 'replacement');",
+"boolean matches = Pattern.matches('pattern', text);",
+"String text = html.replaceAll('<[^>]+>', '');",
+"String encoded = StringEscapeUtils.escapeHtml4(html);",
+"String decoded = StringEscapeUtils.unescapeHtml4(html);",
+"JFrame frame = new JFrame('Simple GUI'); frame.setSize(300, 200); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true);",
+"JFrame frame = new JFrame(); JButton button = new JButton(\"Click Me\"); frame.add(button);",
+    "button.addActionListener(e -> JOptionPane.showMessageDialog(frame, \"Button Clicked!\"));",
+    "String input = JOptionPane.showInputDialog(frame, \"Enter something:\");",
+    "frame.setTitle(\"My Window\");",
+    "frame.setSize(400, 300);",
+    "frame.setLocationRelativeTo(null);",
+    "JMenuBar menuBar = new JMenuBar(); JMenu menu = new JMenu(\"File\"); menuBar.add(menu); frame.setJMenuBar(menuBar);",
+    "JComboBox<String> comboBox = new JComboBox<>(new String[]{\"Option 1\", \"Option 2\"}); frame.add(comboBox);",
+    "JRadioButton radioButton = new JRadioButton(\"Select Me\"); frame.add(radioButton);",
+    "JCheckBox checkBox = new JCheckBox(\"Check Me\"); frame.add(checkBox);",
+    "JLabel label = new JLabel(new ImageIcon(\"image.jpg\")); frame.add(label);",
+    "Clip clip = AudioSystem.getClip(); clip.open(AudioSystem.getAudioInputStream(new File(\"audio.wav\"))); clip.start();",
+    "JFrame videoFrame = new JFrame(); Player player = Manager.createRealizedPlayer(new File(\"video.mp4\").toURI().toURL()); player.start();",
+    "long currentTime = player.getTimeNanoseconds();",
+    "Robot robot = new Robot(); BufferedImage screenshot = robot.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));",
+    "Robot robot = new Robot(); robot.delay(5000); BufferedImage screenRecording = robot.createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));",
+    "PointerInfo pointerInfo = MouseInfo.getPointerInfo(); Point point = pointerInfo.getLocation();",
+    "Robot robot = new Robot(); robot.keyPress(KeyEvent.VK_A); robot.keyRelease(KeyEvent.VK_A);",
+    "Robot robot = new Robot(); robot.mousePress(InputEvent.BUTTON1_DOWN_MASK); robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);",
+    "long timestamp = System.currentTimeMillis();",
+    "Date date = new Date(timestamp);",
+    "long timestamp = date.getTime();",
+    "int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK);",
+    "int daysInMonth = Calendar.getInstance().getActualMaximum(Calendar.DAY_OF_MONTH);",
+    "Calendar calendar = Calendar.getInstance(); calendar.set(Calendar.DAY_OF_YEAR, 1); Date firstDayOfYear = calendar.getTime();",
+    "Calendar calendar = Calendar.getInstance(); calendar.set(Calendar.DAY_OF_YEAR, calendar.getActualMaximum(Calendar.DAY_OF_YEAR)); Date lastDayOfYear = calendar.getTime();",
+    "Calendar calendar = Calendar.getInstance(); calendar.set(Calendar.DAY_OF_MONTH, 1); Date firstDayOfMonth = calendar.getTime();",
+    "Calendar calendar = Calendar.getInstance(); calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH)); Date lastDayOfMonth = calendar.getTime();",
+    "int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK); boolean isWeekday = dayOfWeek >= Calendar.MONDAY && dayOfWeek <= Calendar.FRIDAY;",
+    "int dayOfWeek = Calendar.getInstance().get(Calendar.DAY_OF_WEEK); boolean isWeekend = dayOfWeek == Calendar.SATURDAY || dayOfWeek == Calendar.SUNDAY;",
+    "int hour = Calendar.getInstance().get(Calendar.HOUR_OF_DAY);",
+    "int minute = Calendar.getInstance().get(Calendar.MINUTE);",
+    "int second = Calendar.getInstance().get(Calendar.SECOND);",
+    "Thread.sleep(1000);",
+    "long millisTimestamp = System.currentTimeMillis();",
+    "SimpleDateFormat sdf = new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\"); String formattedDate = sdf.format(new Date());",
+    "SimpleDateFormat sdf = new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\"); Date date = sdf.parse(\"2023-10-01 12:00:00\");",
+    "Thread thread = new Thread(() -> {}); thread.start();",
+    "Thread.sleep(1000);",
+    "ExecutorService executor = Executors.newFixedThreadPool(2); executor.submit(() -> {}); executor.submit(() -> {});",
+    "String threadName = Thread.currentThread().getName();",
+    "Thread thread = new Thread(() -> {}); thread.setDaemon(true); thread.start();",
+    "ReentrantLock lock = new ReentrantLock(); lock.lock(); try {} finally { lock.unlock(); }",
+    "Process process = Runtime.getRuntime().exec(\"notepad.exe\");",
+    "long pid = process.pid();",
+    "boolean isAlive = process.isAlive();",
+    "ExecutorService executor = Executors.newFixedThreadPool(2); executor.submit(() -> {}); executor.submit(() -> {});",
+    "BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(); queue.put(1); int value = queue.take();",
+    "PipedInputStream in = new PipedInputStream(); PipedOutputStream out = new PipedOutputStream(in);",
+    "Thread.sleep(1000);",
+    "Process process = Runtime.getRuntime().exec(\"ls\");",
+    "BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream())); String line = reader.readLine();",
+    "int exitCode = process.waitFor();",
+    "boolean isSuccess = exitCode == 0;",
+    "String scriptPath = new File(\"\").getAbsolutePath();",
+    "String[] args = new String[]{\"arg1\", \"arg2\"};",
+    "Parser parser = new Parser(); parser.parse(args);",
+    "parser.printHelp();",
+    "ModuleLayer layer = ModuleLayer.boot(); layer.modules().forEach(System.out::println);",
+    "Process process = Runtime.getRuntime().exec(\"pip install package\");",
+    "Process process = Runtime.getRuntime().exec(\"pip uninstall package\");",
+    "String version = Package.getPackage(\"package\").getImplementationVersion();",
+    "Process process = Runtime.getRuntime().exec(\"python -m venv venv\");",
+    "Process process = Runtime.getRuntime().exec(\"pip list\");",
+    "Process process = Runtime.getRuntime().exec(\"pip install --upgrade package\");",
+    "Connection conn = DriverManager.getConnection(\"jdbc:sqlite:sample.db\");",
+    "Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery(\"SELECT * FROM table\");",
+    "PreparedStatement pstmt = conn.prepareStatement(\"INSERT INTO table (column) VALUES (?)\"); pstmt.setString(1, \"value\"); pstmt.executeUpdate();",
+    "PreparedStatement pstmt = conn.prepareStatement(\"DELETE FROM table WHERE id = ?\"); pstmt.setInt(1, 1); pstmt.executeUpdate();",
+    "PreparedStatement pstmt = conn.prepareStatement(\"UPDATE table SET column = ? WHERE id = ?\"); pstmt.setString(1, \"new_value\"); pstmt.setInt(2, 1); pstmt.executeUpdate();",
+    "PreparedStatement pstmt = conn.prepareStatement(\"SELECT * FROM table\"); ResultSet rs = pstmt.executeQuery();",
+    "PreparedStatement pstmt = conn.prepareStatement(\"SELECT * FROM table WHERE column = ?\"); pstmt.setString(1, \"value\"); ResultSet rs = pstmt.executeQuery();",
+    "conn.close();",
+    "Statement stmt = conn.createStatement(); stmt.execute(\"CREATE TABLE table (id INT, column VARCHAR(255))\");",
+    "Statement stmt = conn.createStatement(); stmt.execute(\"DROP TABLE table\");",
+    "DatabaseMetaData metaData = conn.getMetaData(); ResultSet rs = metaData.getTables(null, null, \"table\", null); boolean exists = rs.next();",
+    "DatabaseMetaData metaData = conn.getMetaData(); ResultSet rs = metaData.getTables(null, null, null, new String[]{\"TABLE\"});",
+    "Session session = sessionFactory.openSession(); session.save(new Entity());",
+    "Session session = sessionFactory.openSession(); List<Entity> entities = session.createQuery(\"FROM Entity\").list();",
+    "Session session = sessionFactory.openSession(); session.delete(session.get(Entity.class, 1));",
+    "Session session = sessionFactory.openSession(); Entity entity = session.get(Entity.class, 1); entity.setColumn(\"new_value\"); session.update(entity);",
+    "class Entity { @Id @GeneratedValue private int id; private String column; }",
+    "class ChildEntity extends ParentEntity {}",
+    "class Entity { @Id @GeneratedValue private int id; }",
+    "class Entity { @Column(unique = true) private String column; }",
+    "class Entity { @Column(columnDefinition = \"VARCHAR(255) DEFAULT 'default_value'\") private String column; }",
+    "CSVWriter writer = new CSVWriter(new FileWriter(\"output.csv\")); writer.writeNext(new String[]{\"column1\", \"column2\"});",
+    "Workbook workbook = new XSSFWorkbook(); Sheet sheet = workbook.createSheet(\"Sheet1\"); FileOutputStream fileOut = new FileOutputStream(\"workbook.xlsx\"); workbook.write(fileOut);",
+    "Gson gson = new Gson(); String json = gson.toJson(new Entity());",
+    "Workbook workbook = WorkbookFactory.create(new File(\"workbook.xlsx\")); Sheet sheet = workbook.getSheetAt(0);",
+    "Workbook workbook1 = WorkbookFactory.create(new File(\"workbook1.xlsx\")); Workbook workbook2 = WorkbookFactory.create(new File(\"workbook2.xlsx\")); Sheet sheet = workbook1.createSheet(\"Merged\");",
+    "Workbook workbook = new XSSFWorkbook(); Sheet sheet = workbook.createSheet(\"New Sheet\");",
+    "Sheet sheet1 = workbook.getSheetAt(0); Sheet sheet2 = workbook.createSheet(\"Copy\"); CellStyle style = sheet1.getRow(0).getCell(0).getCellStyle(); sheet2.getRow(0).getCell(0).setCellStyle(style);",
+    "CellStyle style = workbook.createCellStyle(); style.setFillForegroundColor(IndexedColors.RED.getIndex()); style.setFillPattern(FillPatternType.SOLID_FOREGROUND);",
+    "Font font = workbook.createFont(); font.setBold(true); CellStyle style = workbook.createCellStyle(); style.setFont(font);",
+    "Sheet sheet = workbook.getSheetAt(0); String cellValue = sheet.getRow(0).getCell(0).getStringCellValue();",
+    "Sheet sheet = workbook.getSheetAt(0); sheet.getRow(0).getCell(0).setCellValue(\"New Value\");",
+    "BufferedImage image = ImageIO.read(new File(\"image.jpg\")); int width = image.getWidth(); int height = image.getHeight();",
+    "BufferedImage originalImage = ImageIO.read(new File(\"image.jpg\")); BufferedImage resizedImage = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB); Graphics2D g = resizedImage.createGraphics(); g.drawImage(originalImage, 0, 0, 100, 100, null);"
 
 
+
+    
 ]
 
 # 全局服务状态