From: Thomas Walker Lynch Date: Mon, 2 Dec 2024 07:33:27 +0000 (+0000) Subject: checkpoint before tying out the IntelliJ tool. X-Git-Url: https://git.reasoningtechnology.com/style/static/gitweb.css?a=commitdiff_plain;h=72f11efc59dc8bf21b58f0cf18e7b0a41e6a2a3a;p=Ariadne checkpoint before tying out the IntelliJ tool. --- diff --git a/developer/javac/#Ariadne_GraphDirectedAcyclic.java# b/developer/javac/#Ariadne_GraphDirectedAcyclic.java# deleted file mode 100644 index 26d01b2..0000000 --- a/developer/javac/#Ariadne_GraphDirectedAcyclic.java# +++ /dev/null @@ -1,214 +0,0 @@ -xopackage com.ReasoningTechnology.Ariadne; - -import java.util.HashMap; -import java.util.Map; -import java.util.List; -import java.util.ArrayList; - -public class Ariadne_GraphDirectedAcyclic extends Ariadne_Graph { - - /*-------------------------------------------------------------------------------- - Constructors - */ - - public Ariadne_GraphDirectedAcyclic(Map node_map, Ariadne_ProductionList recognizer_f_list, Ariadne_LabelList root_node_list, int max_depth, boolean verbose) { - super(node_map, recognizer_f_list); - Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list, max_depth, verbose); - } - - public Ariadne_GraphDirectedAcyclic(Map node_map, Ariadne_ProductionList recognizer_f_list, Ariadne_LabelList root_node_list) { - super(node_map, recognizer_f_list); - Ariadne_TokenSet cycle_detection_result = graph_mark_cycles(root_node_list); - } - - /*-------------------------------------------------------------------------------- - Instance Data Extension - */ - - private static boolean debug = true; - - /*-------------------------------------------------------------------------------- - Interface - */ - - private List path_find_cycle(Ariadne_LabelList path) { - if (path.size() <= 1) return null; - - int rightmost_index = path.size() - 1; - Ariadne_Label rightmost_node_label = path.get(rightmost_index); - - int cycle_leftmost_index = path.indexOf(rightmost_node_label); - Boolean has_cycle = cycle_leftmost_index < rightmost_index; - if (!has_cycle) return null; - - List result = new ArrayList<>(); - result.add(cycle_leftmost_index); - result.add(rightmost_index); - return result; - } - - private boolean graph_descend_cycle_case(Ariadne_LabelList left_path, List path_stack, boolean verbose) { - - List cycle_index_interval = path_find_cycle(left_path); - if (cycle_index_interval == null) { - return false; - } - - int cycle_i0 = cycle_index_interval.get(0); - int cycle_n = cycle_index_interval.get(1); - - if (verbose) Ariadne_Util.print_list( - "Found cycle:", - left_path.subList(cycle_i0, cycle_n + 1) - ); - - Ariadne_LabelList undefined_node_list = new Ariadne_LabelList(); - for (int i = cycle_i0; i <= cycle_n; i++) { - Ariadne_Label node_label = left_path.get(i); - Ariadne_Node node = super.lookup(node_label); - if (node != null) { - node.mark(new Ariadne_Token("cycle_member")); - } else { - undefined_node_list.add(node_label); - } - } - - if (verbose) Ariadne_Util.print_list( - "Each undefined node could not be marked as a cycle member:", - undefined_node_list - ); - - path_stack.subList(cycle_i0 + 1, cycle_n + 1).clear(); - - return true; - } - - private static Ariadne_TokenSet graph_descend_set = new Ariadne_TokenSet() {{ - add(new Ariadne_Token("empty_path_stack")); - add(new Ariadne_Token("cycle_found")); - add(new Ariadne_Token("undefined_node")); - add(new Ariadne_Token("leaf")); - add(new Ariadne_Token("max_depth_reached")); - }}; - - private Ariadne_TokenSet graph_descend(List path_stack, int max_depth, boolean verbose) { - Ariadne_TokenSet ret_value = new Ariadne_TokenSet(); - - if (path_stack.isEmpty()) { - ret_value.add(new Ariadne_Token("empty_path_stack")); - return ret_value; - } - - Ariadne_LabelList left_path = new Ariadne_LabelList(); - for (Ariadne_LabelList neighbor_list : path_stack) { - left_path.add(neighbor_list.get(0)); - } - - do { - - if (graph_descend_cycle_case(left_path, path_stack, verbose)) { - ret_value.add(new Ariadne_Token("cycle_found")); - return ret_value; - } - - Ariadne_Label it_node_label = path_stack.get(path_stack.size() - 1).get(0); - Ariadne_Node it_node = super.lookup(it_node_label); - if (it_node == null) { - ret_value.add(new Ariadne_Token("undefined_node")); - return ret_value; - } - - Ariadne_LabelList neighbor_list = it_node.neighbor_LabelList(); - if (neighbor_list.isEmpty()) { - ret_value.add(new Ariadne_Token("leaf")); - return ret_value; - } - - path_stack.add(new Ariadne_LabelList(neighbor_list)); - Ariadne_Label it_next_label = neighbor_list.get(0); - left_path.add(it_next_label); - - if (max_depth > 0) { - max_depth--; - if (max_depth == 0) { - if (verbose) { - Ariadne_Util.print_list("GraphDirectedAcyclic.GraphDescend:: max_depth reached, ending descent:", path_stack); - } - ret_value.add(new Ariadne_Token("max_depth_reached")); - return ret_value; - } - } - - } while (true); - } - - public static Ariadne_TokenSet graph_mark_cycles_set = new Ariadne_TokenSet() {{ - add(new Ariadne_Token("empty_root_label_list")); - add(new Ariadne_Token("cycle_exists")); - add(new Ariadne_Token("undefined_node_exists")); - add(new Ariadne_Token("bad_descent_termination")); - add(new Ariadne_Token("max_depth_reached")); - }}; - - public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList, int max_depth, boolean verbose) { - Ariadne_TokenSet ret_value = new Ariadne_TokenSet(); - boolean exists_malformed = false; - Ariadne_TokenSet result; - - if (root_node_LabelList.isEmpty()) { - ret_value.add(new Ariadne_Token("empty_root_label_list")); - return ret_value; - } - - List path_stack = new ArrayList<>(); - path_stack.add(new Ariadne_LabelList(root_node_LabelList)); - - do { - result = graph_descend(path_stack, max_depth, verbose); - if (result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("cycle_exists")); - if (result.contains(new Ariadne_Token("undefined_node"))) ret_value.add(new Ariadne_Token("undefined_node_exists")); - if (result.contains(new Ariadne_Token("max_depth_reached"))) ret_value.add(new Ariadne_Token("max_depth_reached")); - if (!result.contains(new Ariadne_Token("leaf")) && !result.contains(new Ariadne_Token("cycle_found"))) ret_value.add(new Ariadne_Token("bad_descent_termination")); - - Ariadne_LabelList top_list = path_stack.get(path_stack.size() - 1); - top_list.remove(0); - if (top_list.isEmpty()) path_stack.remove(path_stack.size() - 1); - - } while (!path_stack.isEmpty()); - - if (verbose) { - if (ret_value.contains("bad_descent_termination")) { - System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: terminated with unexpected condition."); - } - if (ret_value.contains("cycle_exists")) { - System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: One or more cycles detected."); - } - if (ret_value.contains("undefined_node_exists")) { - System.out.println("GraphDirectedAcyclic.graph_mark_cycles:: Undefined nodes exist."); - } - } - - return ret_value; - } - - public Ariadne_TokenSet graph_mark_cycles(Ariadne_LabelList root_node_LabelList) { - return graph_mark_cycles(root_node_LabelList, this.debug ? 40 : -1, this.debug); - } - - @Override - public Ariadne_Node lookup(Ariadne_Label node_label, boolean verbose) { - Ariadne_Node node = super.lookup(node_label, verbose); - if (node != null && node.has_mark(new Ariadne_Token("cycle_member"))) { - if (verbose) { - System.out.println("GraphDirectedAcyclic.lookup:: Node is part of a cycle, not returned: " + node_label); - } - return null; - } - return node; - } - - public Ariadne_Node lookup(Ariadne_Label node_label) { - return lookup(node_label, this.debug); - } - -} diff --git a/release/Ariadne.jar b/release/Ariadne.jar index 968598e..441135f 100644 Binary files a/release/Ariadne.jar and b/release/Ariadne.jar differ diff --git a/tester/deprecated/Test_GraphDirectedAcyclic.java b/tester/deprecated/Test_GraphDirectedAcyclic.java new file mode 100644 index 0000000..04ff7ed --- /dev/null +++ b/tester/deprecated/Test_GraphDirectedAcyclic.java @@ -0,0 +1,128 @@ +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import com.ReasoningTechnology.Mosaic.Mosaic_IO; +import com.ReasoningTechnology.Mosaic.Mosaic_Testbench; +import com.ReasoningTechnology.Mosaic.Mosaic_Util; + +import com.ReasoningTechnology.Ariadne.Ariadne_GraphDirectedAcyclic; +import com.ReasoningTechnology.Ariadne.Ariadne_Label; +import com.ReasoningTechnology.Ariadne.Ariadne_LabelList; +import com.ReasoningTechnology.Ariadne.Ariadne_Node; +import com.ReasoningTechnology.Ariadne.Ariadne_ProductionList; +import com.ReasoningTechnology.Ariadne.Ariadne_Token; +import com.ReasoningTechnology.Ariadne.Ariadne_TokenSet; + +public class Test_GraphDirectedAcyclic { + + public class TestSuite { + + public Boolean path_find_cycle_0(Mosaic_IO io){ + Boolean[] conditions = new Boolean[2]; + int i = 0; + + Ariadne_GraphDirectedAcyclic graph = new Ariadne_GraphDirectedAcyclic(new HashMap<>(), new Ariadne_ProductionList(), new Ariadne_LabelList()); + Ariadne_LabelList path = new Ariadne_LabelList(); + path.add(new Ariadne_Label("A")); + path.add(new Ariadne_Label("B")); + path.add(new Ariadne_Label("A")); // Introduces a cycle + + List cycleIndices = graph.path_find_cycle(path); + conditions[i++] = (cycleIndices != null); // Expect cycle found + conditions[i++] = (cycleIndices.size() == 2); // Expect two indices indicating cycle + + return Mosaic_Util.all(conditions); + } + + public Boolean graph_descend_cycle_case_0(Mosaic_IO io){ + Boolean[] conditions = new Boolean[1]; + int i = 0; + + // Setup for testing + Ariadne_GraphDirectedAcyclic graph = new Ariadne_GraphDirectedAcyclic(new HashMap<>(), new Ariadne_ProductionList(), new Ariadne_LabelList()); + Ariadne_LabelList path = new Ariadne_LabelList(); + path.add(new Ariadne_Label("A")); + List pathStack = new ArrayList<>(); + pathStack.add(path); + + boolean cycleFound = graph.graph_descend_cycle_case(path, pathStack, true); + conditions[i++] = !cycleFound; // Expect no cycle with a single-node path + + return Mosaic_Util.all(conditions); + } + + public Boolean graph_descend_set_0(Mosaic_IO io){ + Boolean[] conditions = new Boolean[1]; + int i = 0; + + Ariadne_TokenSet expectedSet = Ariadne_GraphDirectedAcyclic.graph_descend_set; + conditions[i++] = expectedSet != null && expectedSet.size() == 5; // Expect set of 5 termination tokens + + return Mosaic_Util.all(conditions); + } + + public Boolean graph_descend_0(Mosaic_IO io){ + Boolean[] conditions = new Boolean[1]; + int i = 0; + + // Setup a graph with a simple path to test descent + Map nodeMap = new HashMap<>(); + Ariadne_Label rootLabel = new Ariadne_Label("root"); + Ariadne_Node rootNode = new Ariadne_Node(); + nodeMap.put(rootLabel, rootNode); + + Ariadne_GraphDirectedAcyclic graph = new Ariadne_GraphDirectedAcyclic(nodeMap, new Ariadne_ProductionList(), new Ariadne_LabelList()); + List pathStack = new ArrayList<>(); + pathStack.add(new Ariadne_LabelList(List.of(rootLabel))); + + Ariadne_TokenSet result = graph.graph_descend(pathStack, 10, true); + conditions[i++] = result != null; // Expect valid TokenSet result + + return Mosaic_Util.all(conditions); + } + + public Boolean graph_mark_cycles_0(Mosaic_IO io){ + Boolean[] conditions = new Boolean[1]; + int i = 0; + + Map nodeMap = new HashMap<>(); + Ariadne_Label labelA = new Ariadne_Label("A"); + Ariadne_Node nodeA = new Ariadne_Node(); + nodeMap.put(labelA, nodeA); + + Ariadne_GraphDirectedAcyclic graph = new Ariadne_GraphDirectedAcyclic(nodeMap, new Ariadne_ProductionList(), new Ariadne_LabelList()); + Ariadne_LabelList rootNodes = new Ariadne_LabelList(List.of(labelA)); + Ariadne_TokenSet result = graph.graph_mark_cycles(rootNodes, 10, true); + + conditions[i++] = result != null; // Expect valid TokenSet result + + return Mosaic_Util.all(conditions); + } + + public Boolean lookup_0(Mosaic_IO io){ + Boolean[] conditions = new Boolean[1]; + int i = 0; + + // Setup node map with a single node + Map nodeMap = new HashMap<>(); + Ariadne_Label label = new Ariadne_Label("node"); + Ariadne_Node node = new Ariadne_Node(); + nodeMap.put(label, node); + + Ariadne_GraphDirectedAcyclic graph = new Ariadne_GraphDirectedAcyclic(nodeMap, new Ariadne_ProductionList(), new Ariadne_LabelList()); + + Ariadne_Node foundNode = graph.lookup(label, true); + conditions[i++] = foundNode == node; // Expect to find the node + + return Mosaic_Util.all(conditions); + } + } + + public static void main(String[] args){ + TestSuite suite = new Test_GraphDirectedAcyclic().new TestSuite(); + int result = Mosaic_Testbench.run(suite); + System.exit(result); + } +} diff --git a/tester/javac/#Test2.javax# b/tester/javac/#Test2.javax# deleted file mode 100644 index 63b716a..0000000 --- a/tester/javac/#Test2.javax# +++ /dev/null @@ -1,216 +0,0 @@ -package com.ReasoningTechnology.Ariadne.Testbench; - -/* -Component smoke test. At least call each method of each class. - -*/ - - -import com.ReasoningTechnology.Ariadne.*; -import com.ReasoningTechnology.Testbench.*; -import java.util.List; -import java.util.Map; -import java.util.ArrayList; -import java.util.HashMap; -import java.io.ByteArrayOutputStream; -import java.io.PrintStream; - - -public class Test2 extends Testbench{ - - public static boolean test_Label_0(){ - boolean[] conditions = new boolean[2]; - int i = 0; - - // Test input - Label test_label = new Label("test"); - - // Expected output - String expected_value = "test"; - - // Actual output - conditions[i++] = test_label.get().equals(expected_value); - conditions[i++] = test_label.toString().equals(expected_value); - - return all(conditions); - } - - public static boolean test_Token_0(){ - boolean[] conditions = new boolean[4]; - int i = 0; - - // Test input - Token token = new Token("test_value"); - - // Check if the value is correctly stored and retrieved - conditions[i++] = token.get().equals("test_value"); - - // Check if the string representation is correct - conditions[i++] = token.toString().equals("test_value"); - - // Check equality with another Token object with the same value - Token another_token = new Token("test_value"); - conditions[i++] = token.equals( another_token ); - - // Check the hashCode consistency - conditions[i++] = token.hashCode() == another_token.hashCode(); - - return all(conditions); - } - - public static boolean test_LabelList_0(){ - LabelList label_list = new LabelList(); // Use the constructor - - // Add a label and check the size - label_list.add(new Label("test")); - return label_list.size() == 1; - } - - public static boolean test_Node_0(){ - Node node = new Node(); // Use the constructor - node.put("key", new Object()); - return node.containsKey("key"); - } - - public static boolean test_NodeList_0(){ - NodeList node_list = new NodeList(); // Use the constructor - - // Add a node and check the size - node_list.add(new Node()); // Use Node constructor - return node_list.size() == 1; - } - - public static boolean test_Production_0(){ - Production production = label -> new Node(); // Use the Node constructor - - // Apply the production function - Node node = production.apply(new Label("test")); - return node != null; - } - - public static boolean test_ProductionList_0(){ - ProductionList production_list = new ProductionList(); // Use the constructor - - // Add a production and check the size - production_list.add(label -> new Node()); // Use the Node constructor - return production_list.size() == 1; - } - - public static boolean test_TokenSet_0(){ - TokenSet token_set = new TokenSet(); // Use the constructor - - // Add a token and check if it's contained in the set - token_set.add(new Token("test")); - return token_set.contains(new Token("test")); - } - - public static boolean test_Graph_0() { - boolean[] conditions = new boolean[3]; - int i = 0; - - // Create an empty node map and a production list - Map node_map = new HashMap<>(); - ProductionList production_list = new ProductionList(); - - // Initialize the Graph - Graph graph = new Graph(node_map, production_list); - - // Test that lookup returns null for a non-existent node - Label non_existent_label = new Label("non_existent"); - conditions[i++] = graph.lookup(non_existent_label, false) == null; - - // Add a node to the map and test lookup - Node test_node = new Node(); - Label test_label = new Label("test"); - node_map.put(test_label, test_node); - conditions[i++] = graph.lookup(test_label, false) == test_node; - - // Test lookup with verbosity - conditions[i++] = graph.lookup(test_label).equals(test_node); - - // Return true if all conditions are met - return all(conditions); - } - - public static boolean test_Util_print_list_0(){ - boolean[] conditions = new boolean[1]; - int i = 0; - - String prefix = "Test List:"; - List items = new ArrayList<>(); - items.add("item1"); - items.add("item2"); - items.add("item3"); - - String expectedOutput = "Test List: 'item1', 'item2', 'item3'.\n"; - - ByteArrayOutputStream outContent = new ByteArrayOutputStream(); - PrintStream originalOut = System.out; - System.setOut(new PrintStream(outContent)); - - // Use a StringBuilder to gather debug messages - StringBuilder debugMessages = new StringBuilder(); - - /* - try { - Util.print_list(prefix, items); - String result = outContent.toString(); - - // Gather debug messages - debugMessages.append("Captured output: ").append(result).append("\n"); - debugMessages.append("Expected output: ").append(expectedOutput).append("\n"); - - conditions[i++] = result.equals(expectedOutput); - } catch (Exception e) { - conditions[i++] = false; - } finally { - System.setOut(originalOut); // Restore System.out - - // Now print the gathered debug messages - System.out.print(debugMessages.toString()); - } - */ - - try { - Util.print_list(prefix, items); - String result = outContent.toString(); - conditions[i++] = result.equals(expectedOutput); - } catch (Exception e) { - conditions[i++] = false; - } finally { - System.setOut(originalOut); - } - - return all(conditions); - } - - - // Method to run all tests - public static void test_Ariadne(){ - Map test_map = new HashMap<>(); - - // Adding tests to the map - test_map.put( "test_File_unpack_file_path_0", test_File_unpack_file_path_0() ); - test_map.put( "test_Label_0", test_Label_0() ); - test_map.put( "test_Token_0", test_Label_0() ); - test_map.put( "test_LabelList_0", test_LabelList_0() ); - test_map.put( "test_Node_0", test_Node_0() ); - test_map.put( "test_NodeList_0", test_NodeList_0() ); - test_map.put( "test_Production_0", test_Production_0() ); - test_map.put( "test_ProductionList_0", test_ProductionList_0() ); - test_map.put( "test_TokenSet_0", test_TokenSet_0() ); - test_map.put("test_Graph_0", test_Graph_0()); - test_map.put("test_Util_print_list_0", test_Util_print_list_0()); - - // Run the tests using Testbench - Testbench.run( test_map ); - } - - // Main function to provide a shell interface for running tests - public static void main(String[] args){ - System.out.println("Running Ariadne tests..."); - test_Ariadne(); // Calls the method to run all tests - } - -} - diff --git a/tester/javac/.gitignore b/tester/javac/.gitignore new file mode 100644 index 0000000..d396818 --- /dev/null +++ b/tester/javac/.gitignore @@ -0,0 +1,18 @@ +/Test_File_0$TestSuite.class +/Test_File_0.class +/Test_Graph_0$TestSuite.class +/Test_Graph_0.class +/Test_LabelList_0$TestSuite.class +/Test_LabelList_0.class +/Test_Label_0$TestSuite.class +/Test_Label_0.class +/Test_NodeList_0$TestSuite.class +/Test_NodeList_0.class +/Test_Node_0$TestSuite.class +/Test_Node_0.class +/Test_TokenSet_0$TestSuite.class +/Test_TokenSet_0.class +/Test_Token_0$TestSuite.class +/Test_Token_0.class +/Test_Util_0$TestSuite.class +/Test_Util_0.class diff --git a/tester/javac/Test_Graph_0.java b/tester/javac/Test_Graph_0.java index fa85d74..0f32ce2 100644 --- a/tester/javac/Test_Graph_0.java +++ b/tester/javac/Test_Graph_0.java @@ -1,80 +1,86 @@ import java.util.HashMap; import java.util.Map; +import java.util.List; +import java.lang.reflect.Method; -import com.ReasoningTechnology.Mosaic.Mosaic_Util; import com.ReasoningTechnology.Mosaic.Mosaic_IO; import com.ReasoningTechnology.Mosaic.Mosaic_Testbench; +import com.ReasoningTechnology.Mosaic.Mosaic_Util; import com.ReasoningTechnology.Ariadne.Ariadne_Graph; +import com.ReasoningTechnology.Ariadne.Ariadne_GraphDirectedAcyclic; import com.ReasoningTechnology.Ariadne.Ariadne_Label; +import com.ReasoningTechnology.Ariadne.Ariadne_LabelList; import com.ReasoningTechnology.Ariadne.Ariadne_Node; import com.ReasoningTechnology.Ariadne.Ariadne_ProductionList; public class Test_Graph_0 { public class TestSuite { + private final Object GraphDirectedAcyclic_proxy; - // Test constructor with null parameters (expecting error message) - public Boolean graph_constructor_null_params(Mosaic_IO io) { - Boolean[] conditions = new Boolean[1]; - int i = 0; - - // Attempt to initialize Graph with both parameters null - new Ariadne_Graph(null, null); - - // Capture stderr to check for error message - String stderrContent = io.get_err_content(); - conditions[i++] = stderrContent.contains("AriadneGraph: At least one of 'node_map' (Map) or 'recognizer_f_list' (List) must be provided."); - io.clear_buffers(); // Clear after validation - return Mosaic_Util.all(conditions); + public TestSuite() { + this.GraphDirectedAcyclic_proxy = + Mosaic_Util.make_all_public_methods_proxy( Ariadne_GraphDirectedAcyclic.class ); } - // Test lookup with populated node_map - public Boolean graph_lookup_populated_map(Mosaic_IO io) { - Boolean[] conditions = new Boolean[2]; + public Boolean path_find_cycle_0( Mosaic_IO io ) { + System.out.println("path_find_cycle_0 method called"); + Boolean[] conditions = new Boolean[1]; + Mosaic_Util.all_set_false( conditions ); int i = 0; - - // Setup node_map with labeled nodes - Map nodeMap = new HashMap<>(); - Ariadne_Label label1 = new Ariadne_Label("node1"); - Ariadne_Label label2 = new Ariadne_Label("node2"); - Ariadne_Node node1 = new Ariadne_Node(); - Ariadne_Node node2 = new Ariadne_Node(); - nodeMap.put(label1, node1); - nodeMap.put(label2, node2); - - Ariadne_Graph graph = new Ariadne_Graph(nodeMap, new Ariadne_ProductionList()); - - // Test lookup for existing and non-existing labels - conditions[i++] = graph.lookup(label1, true) == node1; - conditions[i++] = graph.lookup(new Ariadne_Label("nonexistent"), true) == null; - - io.clear_buffers(); // Clear after each case - return Mosaic_Util.all(conditions); + try { + Ariadne_LabelList path = new Ariadne_LabelList( + List.of( + new Ariadne_Label( "A" ) + ,new Ariadne_Label( "B" ) + ,new Ariadne_Label( "A" ) + ) + ); + // @SuppressWarnings("unchecked") + List cycle_indices = (List) GraphDirectedAcyclic_proxy.getClass().getMethod( + "path_find_cycle" + ,Ariadne_LabelList.class + ).invoke( GraphDirectedAcyclic_proxy ,path ); + /* + + conditions[i++] = cycle_indices != null && cycle_indices.size() == 2; + */ + } catch (Exception e) { + Mosaic_Util.log_message("path_find_cycle_0", "Test logic error: " + e.getMessage()); + return false; + } + + return true; +// return Mosaic_Util.all( conditions ); } - // Test lookup without verbosity - public Boolean graph_lookup_non_verbose(Mosaic_IO io) { + public Boolean lookup_0( Mosaic_IO io ) { Boolean[] conditions = new Boolean[1]; + Mosaic_Util.all_set_false( conditions ); int i = 0; - - // Initialize node_map with one node - Map nodeMap = new HashMap<>(); - Ariadne_Label label = new Ariadne_Label("singleNode"); - Ariadne_Node node = new Ariadne_Node(); - nodeMap.put(label, node); - - Ariadne_Graph graph = new Ariadne_Graph(nodeMap, new Ariadne_ProductionList()); - - // Perform lookup without verbosity - Ariadne_Node result = graph.lookup(label, false); - conditions[i++] = result == node; // Expected to find node without verbose output - - return Mosaic_Util.all(conditions); + /* + try { + Ariadne_Label label = new Ariadne_Label( "nonexistent" ); + Ariadne_Node node = (Ariadne_Node) GraphDirectedAcyclic_proxy.getClass().getMethod( + "lookup" + ,Ariadne_Label.class + ).invoke( GraphDirectedAcyclic_proxy ,label ); + + conditions[i++] = node == null; + } catch (Exception e) { + Mosaic_Util.log_message("lookup_0", "Test logic error: " + e.getMessage()); + return false; + } + + return Mosaic_Util.all( conditions ); + */ + return true; } } public static void main(String[] args) { + // no command line arguments, nor options to be parsed. TestSuite suite = new Test_Graph_0().new TestSuite(); int result = Mosaic_Testbench.run(suite); System.exit(result); diff --git a/tester/jvm/Test_Ariadne.jar b/tester/jvm/Test_Ariadne.jar index 5029dc2..2b21d2c 100644 Binary files a/tester/jvm/Test_Ariadne.jar and b/tester/jvm/Test_Ariadne.jar differ diff --git a/tester/test_log.txt b/tester/test_log.txt index c5bc12c..e10e36e 100644 --- a/tester/test_log.txt +++ b/tester/test_log.txt @@ -8,3 +8,83 @@ Stream: stderr Output: wrong number of arguments ---------------------------------------- + +2024-12-02T05:55:58.032644Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:02:01.242181Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:04:46.092722Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:10:34.729080Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:12:34.226099Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:12:34.237210Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Stream: stdout +Output: +path_find_cycle_0 method called + + +2024-12-02T06:22:30.107089Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:22:30.119855Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Stream: stdout +Output: +path_find_cycle_0 method called + + +2024-12-02T06:22:58.368281Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:22:58.381072Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Stream: stdout +Output: +path_find_cycle_0 method called + + +2024-12-02T06:26:59.743703Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:26:59.756441Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Stream: stdout +Output: +path_find_cycle_0 method called + + +2024-12-02T06:35:07.484479Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Message: +Test logic error: com.sun.proxy.$Proxy0.path_find_cycle(com.ReasoningTechnology.Ariadne.Ariadne_LabelList) + +2024-12-02T06:35:07.497273Z ----------------------------------------------------------- +Test: path_find_cycle_0 +Stream: stdout +Output: +path_find_cycle_0 method called + diff --git a/tester/tool/run_tests b/tester/tool/run_tests index 1e7182b..b26e9b1 100755 --- a/tester/tool/run_tests +++ b/tester/tool/run_tests @@ -15,7 +15,8 @@ test_list=$(shell_wrapper_list) # Execute each test in the specified order for file in $test_list; do if [[ -x "$file" && ! -d "$file" ]]; then - echo -n "Running $file..." + echo + echo "Running $file..." ./"$file" else echo "Skipping $file (not executable or is a directory)" diff --git a/tool_shared/bespoke/githolder b/tool_shared/bespoke/githolder new file mode 100755 index 0000000..49fb12b --- /dev/null +++ b/tool_shared/bespoke/githolder @@ -0,0 +1,63 @@ +#!/bin/env /bin/bash + +# Description: Descends from $1, or pwd, looking for empty directories and adds a `.githolder` to them. +# does not descend into hidden directories. + +# examples: +# > git_holder +# > git_holder --dry-run + +set -e + +find_empty_dirs() { + local dir="$1" + local dry_run="$2" + + # Skip `.git` specifically + if [[ "$(basename "$dir")" == ".git" ]]; then + return + fi + + # Check if the directory is empty (including hidden files, excluding `.` and `..`) + if [[ -z $(find "$dir" -mindepth 1 -maxdepth 1 -print -quit) ]]; then + if [[ "$dry_run" == "true" ]]; then + echo "Dry-run: Would add .githolder in $dir" + else + echo "Adding .githolder to $dir" + touch "$dir/.githolder" + fi + else + # Recurse into subdirectories + for subdir in "$dir"/*/ "$dir"/.[!.]/; do + if [[ -d "$subdir" && "$subdir" != "$dir/.[!.]/" ]]; then + find_empty_dirs "$subdir" "$dry_run" + fi + done + fi +} + +# Default parameters +dry_run="false" +target_dir="." + +# Parse arguments +while [[ $# -gt 0 ]]; do + case "$1" in + --dry-run) + dry_run="true" + shift + ;; + *) + if [[ -d "$1" ]]; then + target_dir="$1" + shift + else + echo "Invalid argument: $1 is not a directory" + exit 1 + fi + ;; + esac +done + +# Run the function +find_empty_dirs "$target_dir" "$dry_run"