content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Wed Mar 20 23:06:57 GMT 2024
   */
  
  package org.saxpath;
  
  import org.junit.jupiter.api.Test;
  import static org.junit.jupiter.api.Assertions.*;
  import org.junit.jupiter.api.Timeout;
  import java.util.concurrent.TimeUnit;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.junit.runner.RunWith;
  import org.saxpath.Axis;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class Axis_ESTest extends Axis_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingStringReturningZero() throws Throwable  {
        // Look up a string in the Axis class using the "before" string
        int lookup = Axis.lookup("before");
        
        // Assert that the lookup returns 0, which indicates that the "before" string is not found
        assertEquals(0, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString0() throws Throwable  {
        // No Comments were added
        int lookup = Axis.lookup("descendant-or-self");
        assertEquals(12, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString1() throws Throwable  {
        // No Comments were added
        int lookup = Axis.lookup("self");
        assertEquals(11, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString2() throws Throwable  {
        // No Comments were added
        int lookup = Axis.lookup("namespace");
        assertEquals(10, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString3() throws Throwable  {
        // No Comments were added
        int lookup = Axis.lookup("attribute");
        assertEquals(9, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString4() throws Throwable  {
        // Test the lookup of a value using the "preceding" axis
        int lookup = Axis.lookup("preceding");
        assertEquals(8, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString5() throws Throwable  {
        // Tests the lookup method for the "following" axis
        int lookup = Axis.lookup("following");
        
        // Asserts that the lookup method returns 7
        assertEquals(7, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString6() throws Throwable  {
        // Given a sample XML document
        String xml = "<root><child1/><child2/><child3/></root>";
        
        // When we perform an XPath lookup on the "preceding-sibling" axis
        int lookup = Axis.lookup("preceding-sibling");
        
        // Then the result should be the number of preceding siblings
        assertEquals(6, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString7() throws Throwable  {
        // No Comments were added
        int lookup = Axis.lookup("following-sibling");
        assertEquals(5, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString8() throws Throwable  {
        // Lookup a value from an ancestor element in the DOM tree
        int ancestorValue = Axis.lookup("ancestor");
        
        // Verify that the value is equal to 4
        assertEquals(4, ancestorValue);
        
        // Note: "ancestor" is a variable representing the name of the element to look up.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString9() throws Throwable  {
        // Given: We have a lookup function that takes a string as input and returns an integer value.
        // When: We call the lookup function with the argument "parent".
        int lookup = Axis.lookup("parent");
        
        // Then: The lookup function should return the integer value 3.
        assertEquals(3, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString10() throws Throwable  {
        // This JUnit test verifies that the "descendant" element is located at a specific position in the DOM tree.
        // The position is specified by the value of the "lookup" variable, which is set to 2.
        int lookup = Axis.lookup("descendant");
        assertEquals(2, lookup);
        
        // This test uses the JUnit assertEquals method to verify that the value of the "lookup" variable is equal to 2.
        // The assertEquals method takes two arguments: the expected value and the actual value. In this case, the expected value is 2 and the actual value is the result of the Axis.lookup() method call.
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString11() throws Throwable  {
        // No Comments were added
        int lookup = Axis.lookup("child");
        assertEquals(1, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingString12() throws Throwable  {
        // This test verifies that the "ancestor-or-self" axis returns the correct node when it is used in a XPath expression.
        // The XPath expression is "/bookstore/book/title[@lang='en']/../price".
        // The expected result is 13, which is the price of the first book in the bookstore.
        
        int lookup = Axis.lookup("ancestor-or-self");
        assertEquals(13, lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt0() throws Throwable  {
        // This test checks the functionality of the "lookup" method in the Axis class.
        String lookup = Axis.lookup(13);
        assertNotNull(lookup);
        assertEquals("ancestor-or-self", lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt1() throws Throwable  {
        // No Comments were added
        String lookup = Axis.lookup(12);
        assertNotNull(lookup);
        assertEquals("descendant-or-self", lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt2() throws Throwable  {
        // Test the lookup method with an integer argument of 11
        String lookup = Axis.lookup(11);
        
        // Assert that the returned value is "self"
        assertEquals("self", lookup);
        
        // Assert that the returned value is not null
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt3() throws Throwable  {
        // Given a number 10 is passed to the Axis.lookup method
        String lookup = Axis.lookup(10);
        
        // When the method is called with the given input
        assertEquals("namespace", lookup);
        
        // Then the result should not be null and should equal "namespace"
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt4() throws Throwable  {
        // No Comments were added
        String lookup = Axis.lookup(9);
        assertNotNull(lookup);
        assertEquals("attribute", lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt5() throws Throwable  {
        // Test the Axis.lookup method with an input of 8
        String lookup = Axis.lookup(8);
        // Check that the output is not null
        assertNotNull(lookup);
        // Check that the output is equal to "preceding"
        assertEquals("preceding", lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt6() throws Throwable  {
        // No Comments were added
        String lookup = Axis.lookup(7);
        assertNotNull(lookup);
        assertEquals("following", lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt7() throws Throwable  {
        // Test that the Axis class correctly performs a lookup for the "preceding-sibling" axis.
        String lookup = Axis.lookup(6);
        assertEquals("preceding-sibling", lookup);
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt8() throws Throwable  {
        // No Comments were added
        String lookup = Axis.lookup(5);
        assertEquals("following-sibling", lookup);
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt9() throws Throwable  {
        // Given: The input value of 4 is passed to the Axis.lookup() method.
        String lookup = Axis.lookup(4);
        
        // When: The Axis.lookup() method is called with the input value of 4.
        
        // Then: The output value "ancestor" is returned and not null.
        assertEquals("ancestor", lookup);
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt10() throws Throwable  {
        // Test that the lookup method returns a non-null value for valid input
        String lookup = Axis.lookup(3);
        assertNotNull(lookup);
        
        // Test that the lookup method returns the expected value for valid input
        assertEquals("parent", lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt11() throws Throwable  {
        // No Comments were added
        String lookup = Axis.lookup(2);
        assertEquals("descendant", lookup);
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingIntReturningNull() throws Throwable  {
        // No Comments were added
        String lookup = Axis.lookup(0);
        assertNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testLookupTakingInt12() throws Throwable  {
        // Test that a lookup on a positive integer returns the expected string
        String lookup = Axis.lookup(1);
        assertEquals("child", lookup);
        
        // Test that the lookup result is not null
        assertNotNull(lookup);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testCreatesAxis() throws Throwable  {
        // Create a new instance of the Axis class
        Axis axis = new Axis();
        
        // Test that the DESCENDANT constant has the expected value
        assertEquals(2, Axis.DESCENDANT);
    }
  }
  