content: /*
   * This file was automatically generated by UTestGen and EvoSuite
   * Mon Mar 18 05:47:47 GMT 2024
   */
  
  package fi.vtt.noen.mfw.bundle.probe.shared;
  
  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 fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation;
  import org.evosuite.runtime.EvoRunner;
  import org.evosuite.runtime.EvoRunnerParameters;
  import org.junit.runner.RunWith;
  
  @RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true) 
  public class ProbeInformation_ESTest extends ProbeInformation_ESTest_scaffolding {
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetXmlRpcUrlReturningNonEmptyString() throws Throwable  {
        // Given
        ProbeInformation probeInformation = new ProbeInformation("wrP%Bu4,*)L", ", bmDescription='", ", bmDescription='", "wrP%Bu4,*)L", ", bmDescription='", "wrP%Bu4,*)L", 0, "wrP%Bu4,*)L");
        
        // When
        String xmlRpcUrl = probeInformation.getXmlRpcUrl();
        
        // Then
        assertEquals("wrP%Bu4,*)L", probeInformation.getTargetName());
        assertEquals(", bmDescription='", probeInformation.getBmDescription());
        assertEquals(", bmDescription='", probeInformation.getTargetType());
        assertEquals("wrP%Bu4,*)L", xmlRpcUrl);
        assertEquals(", bmDescription='", probeInformation.getBmClass());
        assertEquals("wrP%Bu4,*)L", probeInformation.getProbeName());
        assertEquals(0, probeInformation.getPrecision());
        assertEquals("wrP%Bu4,*)L", probeInformation.getBmName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetXmlRpcUrlReturningEmptyString() throws Throwable  {
        // Arrange
        ProbeInformation probeInformation = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "", "", "", "", 1860, "");
        
        // Act
        String xmlRpcUrl = probeInformation.getXmlRpcUrl();
        
        // Assert
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetName());
        assertEquals(1860, probeInformation.getPrecision());
        assertEquals("", probeInformation.getBmName());
        assertEquals("", probeInformation.getBmDescription());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetType());
        assertEquals("", xmlRpcUrl);
        assertEquals("", probeInformation.getBmClass());
        assertEquals("", probeInformation.getProbeName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTargetTypeReturningNonEmptyString() throws Throwable  {
        // Given a ProbeInformation object with various fields set to non-default values
        ProbeInformation probeInformation = new ProbeInformation("tko43+", "tko43+", (String) null, "=C-", "", (String) null, 369, (String) null);
        
        // When the target type is retrieved from the ProbeInformation object
        String targetType = probeInformation.getTargetType();
        
        // Then the target type should be an empty string
        assertEquals("", probeInformation.getBmDescription());
        
        // And the target type should not be null
        assertNotNull(targetType);
        
        // And the name of the target should be "tko43+"
        assertEquals("tko43+", probeInformation.getTargetName());
        
        // And the precision of the target should be 369
        assertEquals(369, probeInformation.getPrecision());
        
        // And the name of the target type should be "tko43+"
        assertEquals("tko43+", targetType);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTargetTypeReturningEmptyString() throws Throwable  {
        // Given a ProbeInformation object with a target type and precision of 3600
        ProbeInformation probeInformation = new ProbeInformation("", "", "", "", "", "", 3600, "");
        
        // When the getPrecision method is called on the object
        int actual = probeInformation.getPrecision();
        
        // Then the precision should be equal to 3600
        assertEquals(3600, actual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTargetNameReturningNull() throws Throwable  {
        ProbeInformation probeInformation = new ProbeInformation(null, null, ":u8(C+D9-I(|H", "&R", "Rp7QX-p5W'", "&R", -1660433532, "mfw://local");
        // Verify that the target name is null
        assertNull(probeInformation.getTargetName());
        
        // Verify that the probe name is "&R"
        assertEquals("&R", probeInformation.getProbeName());
        
        // Verify that the XML-RPC URL is "mfw://local"
        assertEquals("mfw://local", probeInformation.getXmlRpcUrl());
        
        // Verify that the precision is -1660433532
        assertEquals(-1660433532, probeInformation.getPrecision());
        
        // Verify that the BM class is ":u8(C+D9-I(|H"
        assertEquals(":u8(C+D9-I(|H", probeInformation.getBmClass());
        
        // Verify that the BM name is "&R"
        assertEquals("&R", probeInformation.getBmName());
        
        // Verify that the BM description is "Rp7QX-p5W'"
        assertEquals("Rp7QX-p5W'", probeInformation.getBmDescription());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTargetNameReturningEmptyString() throws Throwable  {
        // rollbacked to evosuite
        ProbeInformation probeInformation = new ProbeInformation("", "", "", "", ", bmClass='", "", 1413, ", bmClass='");
        String targetName = probeInformation.getTargetName();
        assertEquals(1413, probeInformation.getPrecision());
        assertEquals("", probeInformation.getBmName());
        assertEquals("", targetName);
        assertEquals("", probeInformation.getProbeName());
        assertEquals(", bmClass='", probeInformation.getXmlRpcUrl());
        assertEquals("", probeInformation.getBmClass());
        assertEquals(", bmClass='", probeInformation.getBmDescription());
        assertEquals("", probeInformation.getTargetType());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetProbeNameReturningNull() throws Throwable  {
        // Create a new ProbeInformation object with some test data
        ProbeInformation probeInformation = new ProbeInformation(".%*p CfR#2;iixn", "", ".%*p CfR#2;iixn", "", "", (String) null, 2830, "");
        
        // Test the getProbeName method
        assertEquals("", probeInformation.getProbeName());
        
        // Test the getPrecision method
        assertEquals(2830, probeInformation.getPrecision());
        
        // Test the getBmName method
        assertEquals("", probeInformation.getBmName());
        
        // Test the getTargetName method
        assertEquals(".%*p CfR#2;iixn", probeInformation.getTargetName());
        
        // Test the getXmlRpcUrl method
        assertNull(probeInformation.getXmlRpcUrl());
        
        // Test the getBmDescription method
        assertEquals("", probeInformation.getBmDescription());
        
        // Test the getTargetType method
        assertEquals("", probeInformation.getTargetType());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetProbeNameReturningNonEmptyString() throws Throwable  {
        ProbeInformation probeInformation = new ProbeInformation("Z", "Z", "Z", "Z", "Z", "Z", 0, "measurement_check_interval");
        String probeName = probeInformation.getProbeName();
        // Given that the probe information is initialized with valid data
        
        // When the getter methods are called
        int precision = probeInformation.getPrecision();
        String xmlRpcUrl = probeInformation.getXmlRpcUrl();
        String bmClass = probeInformation.getBmClass();
        String targetName = probeInformation.getTargetName();
        String bmDescription = probeInformation.getBmDescription();
        String targetType = probeInformation.getTargetType();
        
        // Then the correct data is returned for each getter method
        assertEquals(0, precision);
        assertEquals("Z", xmlRpcUrl);
        assertEquals("Z", bmClass);
        assertEquals("Z", targetName);
        assertEquals("Z", bmDescription);
        assertEquals("Z", targetType);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPrecisionReturningZero() throws Throwable  {
        // Test the getPrecision() method of the ProbeInformation class
        ProbeInformation probeInformation = new ProbeInformation("", "", "", "", "", "", 0, "");
        int expectedPrecision = 0;
        int actualPrecision = probeInformation.getPrecision();
        assertEquals(expectedPrecision, actualPrecision);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPrecisionReturningNegative() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation(", bmDescription='", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (String) null, (String) null, (String) null, "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (-1), "P\"%>)Nx");
        int precision = probeInformation.getPrecision();
        assertEquals(", bmDescription='", probeInformation.getTargetName());
        assertEquals((-1), precision);
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getProbeName());
        assertEquals("P\"%>)Nx", probeInformation.getXmlRpcUrl());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetType());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmNameReturningNull() throws Throwable  {
        // Given a ProbeInformation object with some pre-defined values
        ProbeInformation probeInformation = new ProbeInformation("/w%|FT[h:%<$Y", (String) null, "/w%|FT[h:%<$Y", (String) null, (String) null, "/w%|FT[h:%<$Y", 39, "/w%|FT[h:%<$Y");
        
        // When we call the getBmName method on this object
        String bmName = probeInformation.getBmName();
        
        // Then the method should return null
        assertNull(bmName);
        
        // And the precision should be equal to 39
        assertEquals(39, probeInformation.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmNameReturningNonEmptyString() throws Throwable  {
        // rollbacked to evosuite
        ProbeInformation probeInformation = new ProbeInformation("/w%|FT[h:%<$Y", "/w%|FT[h:%<$Y", "/w%|FT[h:%<$Y", "/w%|FT[h:%<$Y", "/w%|FT[h:%<$Y", "/w%|FT[h:%<$Y", (-382), "/w%|FT[h:%<$Y");
        probeInformation.getBmName();
        assertEquals((-382), probeInformation.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmDescriptionReturningNonEmptyString() throws Throwable  {
        // Create a new instance of ProbeInformation using the constructor
        ProbeInformation probeInformation = new ProbeInformation("An;", "$FfoNe~]", "$FfoNe~]", ", probeDescription='", ", probeDescription='", (String) null, 0, (String) null);
        
        // Get the BM description using the getBmDescription method
        String bmDescription = probeInformation.getBmDescription();
        
        // Assert that the target name is "An;"
        assertEquals("An;", probeInformation.getTargetName());
        
        // Assert that the BM class is "$FfoNe~]"
        assertEquals("$FfoNe~]", probeInformation.getBmClass());
        
        // Assert that the precision is 0
        assertEquals(0, probeInformation.getPrecision());
        
        // Assert that the target type is "$FfoNe~]"
        assertEquals("$FfoNe~]", probeInformation.getTargetType());
        
        // Assert that the BM description is not null
        assertNotNull(bmDescription);
        
        // Assert that the BM description is ", probeDescription='"
        assertEquals(", probeDescription='", bmDescription);
        
        // Assert that the BM name is also ", probeDescription='"
        assertEquals(", probeDescription='", probeInformation.getBmName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmDescriptionReturningEmptyString() throws Throwable  {
        // rollbacked to evosuite
        ProbeInformation probeInformation = new ProbeInformation(".%*p CfR#2;iixn", "", ".%*p CfR#2;iixn", "", "", (String) null, 2830, "");
        String bmDescription = probeInformation.getBmDescription();
        assertEquals("", bmDescription);
        assertEquals("", probeInformation.getBmName());
        assertEquals(2830, probeInformation.getPrecision());
        assertEquals(".%*p CfR#2;iixn", probeInformation.getTargetName());
        assertEquals("", probeInformation.getXmlRpcUrl());
        assertNotNull(bmDescription);
        assertEquals("", probeInformation.getTargetType());
        assertEquals(".%*p CfR#2;iixn", probeInformation.getBmClass());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmClassReturningNull() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation("ProbeInformation{targetName='pz!B91v\"Y', targetType='', bmClass='', bmName='$Udg2{OkA38]yil', bmDescription='$Udg2{OkA38]yil', probeDescription='pz!B91v\"Y', precision=39}", (String) null, (String) null, "", "", "", (-2210), "O%<");
        String bmClass = probeInformation.getBmClass();
        assertEquals("ProbeInformation{targetName='pz!B91v\"Y', targetType='', bmClass='', bmName='$Udg2{OkA38]yil', bmDescription='$Udg2{OkA38]yil', probeDescription='pz!B91v\"Y', precision=39}", probeInformation.getTargetName());
        assertEquals("O%<", probeInformation.getXmlRpcUrl());
        assertEquals("", probeInformation.getBmDescription());
        assertEquals("", probeInformation.getProbeName());
        assertEquals((-2210), probeInformation.getPrecision());
        assertNull(bmClass);
        assertEquals("", probeInformation.getBmName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmClassReturningNonEmptyString() throws Throwable  {
        // Create a new ProbeInformation instance with some dummy data
        ProbeInformation probeInformation = new ProbeInformation("/w%|FT[h:%<$Y", "/w%|FT[h:%<$Y", "y'h{>F,^vx?^X*Y(c", "y'h{>F,^vx?^X*Y(c", "y", "m{m<CVIuRvgz!Z8/zR", (-1102), "y'h{>F,^vx?^X*Y(c");
        
        // Assert that the instance variables are set correctly
        assertEquals("/w%|FT[h:%<$Y", probeInformation.getTargetType());
        assertEquals("y'h{>F,^vx?^X*Y(c", probeInformation.getBmName());
        assertEquals("/w%|FT[h:%<$Y", probeInformation.getTargetName());
        assertEquals("m{m<CVIuRvgz!Z8/zR", probeInformation.getProbeName());
        assertEquals((-1102), probeInformation.getPrecision());
        assertEquals("y'h{>F,^vx?^X*Y(c", probeInformation.getXmlRpcUrl());
        assertEquals("y'h{>F,^vx?^X*Y(c", probeInformation.getBmClass());
        assertEquals("y", probeInformation.getBmDescription());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHashCode0() throws Throwable  {
        // rollbacked to evosuite
        ProbeInformation probeInformation = new ProbeInformation("tko43+", "tko43+", (String) null, "=C-", "", (String) null, 369, (String) null);
        probeInformation.hashCode();
        assertEquals("=C-", probeInformation.getBmName());
        assertEquals("tko43+", probeInformation.getTargetType());
        assertEquals("tko43+", probeInformation.getTargetName());
        assertEquals(369, probeInformation.getPrecision());
        assertEquals("", probeInformation.getBmDescription());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHashCode1() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (String) null, "l$?", (String) null, (String) null, "h]/\"o.tb-nKuqG!b+=", 0, "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation");
        probeInformation.hashCode();
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getXmlRpcUrl());
        assertEquals(0, probeInformation.getPrecision());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetName());
        assertEquals("h]/\"o.tb-nKuqG!b+=", probeInformation.getProbeName());
        assertEquals("l$?", probeInformation.getBmClass());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testHashCode2() throws Throwable  {
        // Test for the ProbeInformation class with null values
        ProbeInformation probeInformation = new ProbeInformation((String) null, "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "R", "R", ".", (String) null, (-1), "{=to_");
        // Check if the hash code is equal to the expected value
        assertEquals((-1), probeInformation.hashCode());
        // Check if the precision is set correctly
        assertEquals((-1), probeInformation.getPrecision());
        // Check if the target type is set correctly
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetType());
        // Check if the BM name is set correctly
        assertEquals("R", probeInformation.getBmName());
        // Check if the BM class is set correctly
        assertEquals("R", probeInformation.getBmClass());
        // Check if the XML RPC URL is set correctly
        assertEquals("{=to_", probeInformation.getXmlRpcUrl());
        // Check if the BM description is set correctly
        assertEquals(".", probeInformation.getBmDescription());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningTrue0() throws Throwable  {
        // Given a ProbeInformation object with the same values as another one
        ProbeInformation probeInformation = new ProbeInformation("prob_agnt_mlrpc_port", (String) null, "prob_agnt_mlrpc_port", "prob_agnt_mlrpc_port", "prob_agnt_mlrpc_port", "prob_agnt_mlrpc_port", (-337), "prob_agnt_mlrpc_port");
        ProbeInformation arg0 = new ProbeInformation("prob_agnt_mlrpc_port", (String) null, "prob_agnt_mlrpc_port", "prob_agnt_mlrpc_port", "prob_agnt_mlrpc_port", "prob_agnt_mlrpc_port", (-337), "prob_agnt_mlrpc_port");
        
        // When we call the equals method with another ProbeInformation object with the same values as this one
        boolean equals = probeInformation.equals(arg0);
        
        // Then the equals method should return true, and the getPrecision method should return the expected value of -337
        assertEquals((-337), probeInformation.getPrecision());
        assertTrue(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse0() throws Throwable  {
        // Test that two equal ProbeInformation objects are recognized as such
        ProbeInformation arg0 = new ProbeInformation("prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", (-353), "prob_agent_mlrpc_port");
        ProbeInformation probeInformation = new ProbeInformation("prob_agent_mlrpc_port", (String) null, "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", (-353), "prob_agent_mlrpc_port");
        boolean equals = probeInformation.equals(arg0);
        assertEquals((-353), probeInformation.getPrecision()); // Check that the precision is set correctly
        assertTrue(equals); // Check that the two objects are equal
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningTrue1() throws Throwable  {
        // No Comments were added
        ProbeInformation arg0 = new ProbeInformation((String) null, "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", (-498), "`!0:1b\"pqT");
        ProbeInformation probeInformation = new ProbeInformation((String) null, "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", (-498), "`!0:1b\"pqT");
        boolean equals = probeInformation.equals(arg0);
        assertTrue(equals);
        assertEquals((-498), probeInformation.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse1() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation("[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", (-363), "[ch/w%,FT[h:x<$Y");
        ProbeInformation arg0 = new ProbeInformation("[chw%,FT[h:<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", (-363), "[ch/w%,FT[h:x<$Y");
        boolean equals = probeInformation.equals(arg0);
        assertEquals((-363), arg0.getPrecision());
        assertFalse(equals);
        assertEquals("[ch/w%,FT[h:x<$Y", arg0.getBmName());
        assertEquals("[ch/w%,FT[h:x<$Y", arg0.getBmClass());
        assertEquals("[ch/w%,FT[h:x<$Y", arg0.getProbeName());
        assertEquals("[ch/w%,FT[h:x<$Y", arg0.getTargetType());
        assertEquals("[ch/w%,FT[h:x<$Y", arg0.getBmDescription());
        assertEquals("[ch/w%,FT[h:x<$Y", arg0.getXmlRpcUrl());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse2() throws Throwable  {
        // No Comments were added
        ProbeInformation arg0 = new ProbeInformation("`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", (-375), "`!0:1b\"pqT");
        ProbeInformation probeInformation = new ProbeInformation((String) null, "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", "`!0:1b\"pqT", (-375), "`!0:1b\"pqT");
        boolean equals = probeInformation.equals(arg0);
        assertEquals((-375), probeInformation.getPrecision());
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse3() throws Throwable  {
        // rollbacked to evosuite
        ProbeInformation arg0 = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (-360), "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation");
        ProbeInformation probeInformation = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (String) null, (-360), "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation");
        boolean equals = probeInformation.equals(arg0);
        assertFalse(equals);
        assertEquals((-360), probeInformation.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse4() throws Throwable  {
        // Given two instances of the ProbeInformation class with different values for the precision field
        ProbeInformation probeInformation1 = new ProbeInformation("[ch/w%,FT[h:%<$Y", (String) null, "[ch/w%,FT[h:%<$Y", (String) null, (String) null, "[ch/w%,FT[h:%<$Y", (-391), (String) null);
        ProbeInformation probeInformation2 = new ProbeInformation((String) null, "[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", (String) null, (String) null, (String) null, (-391), "[ch/w%,FT[h:%<$Y");
        
        // When we compare these instances with the equals method
        boolean result = probeInformation1.equals(probeInformation2);
        
        // Then the result should be false, as the precision field is different between the two instances
        assertFalse(result);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse5() throws Throwable  {
        ProbeInformation probeInfo = new ProbeInformation("[ch/w%,FT[h:%<$Y", (String) null, "[ch/w%,FT[h:%<$Y", (String) null, (String) null, "[ch/w%,FT[h:%<$Y", (-391), (String) null);
        ProbeInformation argument0 = new ProbeInformation((String) null, "[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", (String) null, (String) null, (-391), "[ch/w%,FT[h:%<$Y");
        boolean isEqual = probeInfo.equals(argument0);
        // Test that the precision of the two objects is equal
        assertEquals((-391), argument0.getPrecision());
        // Test that the equality method returns false when comparing two different objects with the same value
        assertFalse(isEqual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse6() throws Throwable  {
        // Given two instances of ProbeInformation with the same values
        ProbeInformation probeInfo1 = new ProbeInformation("[h/w%|FT[h:%<$Y", (String) null, "[h/w%|FT[h:%<$Y", (String) null, (String) null, "[h/w%|FT[h:%<$Y", (-399), (String) null);
        ProbeInformation probeInfo2 = new ProbeInformation((String) null, "[h/w%|FT[h:%<$Y", "[h/w%|FT[h:%<$Y", "[h/w%|FT[h:%<$Y", "[h/w%|FT[h:%<$Y", (String) null, (-399), "[h/w%|FT[h:%<$Y");
        
        // When we compare them for equality
        boolean areEqual = probeInfo1.equals(probeInfo2);
        
        // Then they should not be equal
        assertFalse(areEqual);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse7() throws Throwable  {
        // No Comments were added
        ProbeInformation arg0 = new ProbeInformation("[ch/w%,FT[h:%<$Y", (String) null, "[ch/w%,FT[h:%<$Y", (String) null, (String) null, "[ch/w%,FT[h:%<$Y", (-382), (String) null);
        ProbeInformation probeInformation = new ProbeInformation((String) null, "[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", (String) null, (String) null, (-382), "[ch/w%,FT[h:%<$Y");
        boolean equals = probeInformation.equals(arg0);
        assertEquals((-382), probeInformation.getPrecision());
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse8() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation((String) null, ">rM0TZ%", (String) null, "=}Zl1L+", "&UP?Yx* )OA%Y4&b3W", "&UP?Yx* )OA%Y4&b3W", 58, (String) null);
        ProbeInformation arg0 = new ProbeInformation("&UP?Yx* )OA%Y4&b3W", (String) null, (String) null, (String) null, "=}Zl1L+", "&UP?Yx* )OA%Y4&b3W", 58, "&UP?Yx* )OA%Y4&b3W");
        boolean equals = probeInformation.equals(arg0);
        assertFalse(equals);
        assertEquals("&UP?Yx* )OA%Y4&b3W", probeInformation.getBmDescription());
        assertEquals("=}Zl1L+", arg0.getBmDescription());
        assertEquals("&UP?Yx* )OA%Y4&b3W", arg0.getXmlRpcUrl());
        assertEquals("=}Zl1L+", probeInformation.getBmName());
        assertEquals("&UP?Yx* )OA%Y4&b3W", arg0.getTargetName());
        assertEquals(">rM0TZ%", probeInformation.getTargetType());
        assertEquals(58, arg0.getPrecision());
        assertEquals("&UP?Yx* )OA%Y4&b3W", probeInformation.getProbeName());
        assertEquals("&UP?Yx* )OA%Y4&b3W", arg0.getProbeName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse9() throws Throwable  {
        // Given
        ProbeInformation probeInformation = new ProbeInformation("[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", (-350), "[ch/w%,5FTlh:%WY");
        ProbeInformation arg0 = new ProbeInformation("[ch/w%,5FTlh:%WY", (String) null, "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", "[ch/w%,5FTlh:%WY", (-300), "[ch/w%,5FTlh:%WY");
        // When
        boolean equals = probeInformation.equals(arg0);
        // Then
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse10() throws Throwable  {
        ProbeInformation arg0 = new ProbeInformation(".X>", ".X>", ".X>", ".X>", ".X>", ".X>", (-354), ".X>");
        ProbeInformation probeInformation = new ProbeInformation(".X>", ".X>", (String) null, (String) null, ".X>", ".X>", (-354), ".X>");
        
        // Test that the two objects are not equal
        assertFalse(probeInformation.equals(arg0));
        
        // Test that the precision of the first object is -354
        assertEquals(-354, probeInformation.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse11() throws Throwable  {
        // Given: A ProbeInformation object "probeInfo" with a specific value for precision
        ProbeInformation probeInfo = new ProbeInformation("[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", (-397), "[ch/w%,FT[h:x<$Y");
        
        // When: The "probeInfo" object is compared to another ProbeInformation object with a different value for precision
        ProbeInformation other = new ProbeInformation("[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", "[ch/w%,FT[h:x<$Y", 0, "[ch/w%,FT[h:x<$Y");
        boolean equals = probeInfo.equals(other);
        
        // Then: The "equals" method should return false and the values for precision should be different
        assertFalse(probeInfo.equals((Object) other));
        assertFalse(equals);
        assertEquals(-397, probeInfo.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse12() throws Throwable  {
        // Given two instances of ProbeInformation with different values for the precision
        ProbeInformation probeInformation1 = new ProbeInformation("'z.)", "'z.)", (String) null, "'z.)", "'z.)", "'z.)", (-365), "'z.)");
        ProbeInformation probeInformation2 = new ProbeInformation("'z.)", "'z.)", "'z.)", "'z.)", "'z.)", "'z.)", (-365), "'z.)");
        
        // When we call equals on the two instances
        boolean equals = probeInformation1.equals(probeInformation2);
        
        // Then they should be unequal
        assertFalse(equals);
        
        // And the precision of the first instance should match the expected value
        assertEquals((-365), probeInformation1.getPrecision());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsWithNull() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation((String) null, (String) null, (String) null, (String) null, (String) null, (String) null, (-1599), (String) null);
        boolean equals = probeInformation.equals((Object) null);
        assertEquals((-1599), probeInformation.getPrecision());
        assertFalse(equals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningTrue2() throws Throwable  {
        // Given
        ProbeInformation arg0 = new ProbeInformation("[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", "[ch/w%,FT[h:%<$Y", "[ch/w/~%FT[h:<$Y", "[ch/w/~%FT[h:<$Y", "[ch/w/~%FT[h:<$Y", (-375), "[ch/w/~%FT[h:<$Y");
        boolean expectedEquals = true;
        
        // When
        boolean actualEquals = arg0.equals(arg0);
        
        // Then
        assertEquals((-375), arg0.getPrecision());
        assertEquals(expectedEquals, actualEquals);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testEqualsAndEqualsReturningFalse13() throws Throwable  {
        // Given
        ProbeInformation probeInformation = new ProbeInformation(
        "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation",
        "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation",
        "",
        "",
        "",
        "",
        1860,
        ""
        );
        
        // When
        boolean equals = probeInformation.equals("");
        
        // Then
        assertEquals(1860, probeInformation.getPrecision());
        assertFalse(equals);
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetName());
        assertEquals("", probeInformation.getBmDescription());
        assertEquals("", probeInformation.getBmName());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetType());
        assertEquals("", probeInformation.getBmClass());
        assertEquals("", probeInformation.getXmlRpcUrl());
        assertEquals("", probeInformation.getProbeName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmDescriptionReturningNull() throws Throwable  {
        // Given
        ProbeInformation probeInformation = new ProbeInformation(", bmDescription='", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (String) null, (String) null, (String) null, "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (-1), "P\"%>)Nx");
        
        // When
        String bmDescription = probeInformation.getBmDescription();
        
        // Then
        assertEquals(", bmDescription='", bmDescription);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetXmlRpcUrlReturningNull() throws Throwable  {
        // Create a new ProbeInformation object with some test data
        ProbeInformation probeInformation = new ProbeInformation("Cps:99w=fE{E@(", ", targetType='", ", targetType='", ", targetType='", "Cps:99w=fE{E@(", (String) null, (-1920), (String) null);
        
        // Get the XML-RPC URL from the ProbeInformation object
        String xmlRpcUrl = probeInformation.getXmlRpcUrl();
        
        // Verify that the correct target name is returned
        assertEquals(", targetType='", probeInformation.getBmClass());
        
        // Verify that the correct precision is returned
        assertEquals((-1920), probeInformation.getPrecision());
        
        // Verify that the correct target type is returned
        assertEquals(", targetType='", probeInformation.getTargetType());
        
        // Verify that the correct BM name is returned
        assertEquals("Cps:99w=fE{E@(", probeInformation.getBmName());
        
        // Verify that the correct BM description is returned
        assertEquals("Cps:99w=fE{E@(", probeInformation.getBmDescription());
        
        // Verify that the XML-RPC URL is null
        assertNull(xmlRpcUrl);
        
        // Verify that the target name is correct
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testToString() throws Throwable  {
        // Given a ProbeInformation object with some fields set
        ProbeInformation probeInformation = new ProbeInformation("`!0:1b\"pq/T", "`!0:1b\"pq/T", "`!0:1b\"pq/T", "`!0:1b\"pq/T", "`!0:1b\"pq/T", "`!0:1b\"pq/T", (-341), "`!0:1b\"pq/T");
        
        // When the toString method is called on this object
        String string = probeInformation.toString();
        
        // Then the resulting string should contain all of the fields of the ProbeInformation object, separated by colons and surrounded by curly braces);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetMeasureURI() throws Throwable  {
        // Given
        ProbeInformation probeInformation = new ProbeInformation("prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", "prob_agent_mlrpc_port", (-353), "prob_agent_mlrpc_port");
        String expectedMeasureUri = "-353";
        
        // When
        String actualMeasureUri = probeInformation.getMeasureURI();
        
        // Then
        assertEquals(expectedMeasureUri, actualMeasureUri);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTargetNameReturningNonEmptyString() throws Throwable  {
        // Create an instance of ProbeInformation with the given parameters
        ProbeInformation probeInformation = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "", "", "", "", 1860, "");
        
        // Call the getTargetName method on the ProbeInformation instance and assert that it returns an empty string
        String targetName = probeInformation.getTargetName();
        assertEquals("", targetName);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetTargetTypeReturningNull() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", (String) null, "l$?", (String) null, (String) null, "h]/\"o.tb-nKuqG!b+=", 0, "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation");
        String targetType = probeInformation.getTargetType();
        assertNull(targetType);
        assertEquals("l$?", probeInformation.getBmClass());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetName());
        assertEquals(0, probeInformation.getPrecision());
        assertEquals("h]/\"o.tb-nKuqG!b+=", probeInformation.getProbeName());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getXmlRpcUrl());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmNameReturningEmptyString() throws Throwable  {
        // Given: A ProbeInformation object with a populated BM name and description
        ProbeInformation probeInformation = new ProbeInformation(".%*p CfR#2;iixn", "", ".%*p CfR#2;iixn", "", "", (String) null, 2830, "");
        
        // When: The BM name and description are retrieved from the ProbeInformation object
        String bmName = probeInformation.getBmName();
        String bmDescription = probeInformation.getBmDescription();
        
        // Then: The BM name and description should be as expected
        assertEquals("", bmName);
        assertEquals("", bmDescription);
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetBmClassReturningEmptyString() throws Throwable  {
        // Given
        ProbeInformation probeInformation = new ProbeInformation(
        "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation",
        "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation",
        "",
        "",
        "",
        "",
        1860,
        ""
        );
        
        // When
        String bmClass = probeInformation.getBmClass();
        
        // Then
        assertEquals("", probeInformation.getBmDescription());
        assertEquals("", probeInformation.getProbeName());
        assertEquals(1860, probeInformation.getPrecision());
        assertEquals("", bmClass);
        assertEquals("", probeInformation.getXmlRpcUrl());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetName());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetType());
        assertEquals("", probeInformation.getBmName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetPrecisionReturningPositive() throws Throwable  {
        // No Comments were added
        ProbeInformation probeInformation = new ProbeInformation(".%*p CfR#2;iixn", "", ".%*p CfR#2;iixn", "", "", (String) null, 2830, "");
        int precision = probeInformation.getPrecision();
        assertEquals(2830, precision);
        assertEquals(".%*p CfR#2;iixn", probeInformation.getTargetName());
        assertEquals("", probeInformation.getTargetType());
        assertEquals("", probeInformation.getXmlRpcUrl());
        assertEquals("", probeInformation.getBmDescription());
        assertEquals(".%*p CfR#2;iixn", probeInformation.getBmClass());
        assertEquals("", probeInformation.getBmName());
    }
  
    @Test
    @Timeout(value = 4000 , unit = TimeUnit.MILLISECONDS)
    public void testGetProbeNameReturningEmptyString() throws Throwable  {
        // Arrange
        ProbeInformation probeInformation = new ProbeInformation("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", "", "", "", "", 1860, "");
        String probeName = probeInformation.getProbeName();
        assertEquals("", probeName);
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getBmDescription());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetName());
        assertEquals("", probeInformation.getXmlRpcUrl());
        assertEquals("", probeInformation.getBmName());
        assertEquals(1860, probeInformation.getPrecision());
        assertEquals("fi.vtt.noen.mfw.bundle.probe.shared.ProbeInformation", probeInformation.getTargetType());
    }
  }
  