ArtifactRepository remoteRepository = remoteRepository();
            File deployedFile = new File(remoteRepository.getBasedir(), remoteRepository.pathOf(artifact));
            assertTrue(deployedFile.exists(), "Expected " + deployedFile + ".exists() to return true");
            assertEquals("dummy", new String(Files.readAllBytes(deployedFile.toPath()), StandardCharsets.UTF_8).trim());
        } finally {
            sessionScope.exit();

                        evt.getException().getMessage());
                missingArtifactDescriptor = true;
            }
        }

        assertTrue(
                missingArtifactDescriptor,
                "Expected missing artifact descriptor for org.apache.maven.its:dep-mng5459:pom:0.4.0-20130404.090532-2");
    }

 */
package jcifs.smb;

import jcifs.CIFSException;

/**
 * Exception thrown when an SMB protocol downgrade attack is detected.
 * Indicates that the negotiated protocol version is lower than expected or required.
 *
 * @author mbechler
 *
 */
public class SMBProtocolDowngradeException extends CIFSException {

    /**
     * Serial version UID for serialization compatibility.
     */

    class GetterTests {

        @Test
        @DisplayName("Should return correct values from getters")
        void testGetters() throws CIFSException {
            // When/Then: All getters should return expected values
            assertEquals(mockBinding, handle.getBinding());
            assertTrue(handle.getMaxRecv() > 0);
            assertTrue(handle.getMaxXmit() > 0);

        byte[] buf = new byte[12];
        buf[0] = 0x34; // Low byte
        buf[1] = 0x12; // High byte
        int written = resp.readParameterWordsWireFormat(buf, 0);

        assertEquals(8, written, "Expected readParameterWordsWireFormat to advance 8 bytes");
        assertEquals(0x1234L, resp.getCount(), "Count should reflect value from buffer");
    }

    @Test
    public void testToStringContainsCount() {

        new License().equals(new License());
    }

    @Test
    void testEqualsIdentity() {
        License thing = new License();
        assertTrue(thing.equals(thing), "Expected " + thing + " to equal " + thing);
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new License().toString());
    }

    @Test
    public void testToStringNotNonsense() {

    assertLessThan(STOPPING, TERMINATED);
  }

  private static <T extends Comparable<? super T>> void assertLessThan(T a, T b) {
    if (a.compareTo(b) >= 0) {
      fail(String.format(Locale.ROOT, "Expected %s to be less than %s", a, b));
    }
  }

        assertThat(it.next(), is(sameClass(Number.class)));

        assertThat(it.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test(expected = ClIllegalArgumentException.class)
    public void testInterface() throws Exception {
        new ClassIterator(Iterable.class);
    }

        return LaServletContextUtil.getServletContext();
    }

    /**
     * Verifies that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode
     * @param expectedMode the expected CRUD mode
     * @param errorHook the error hook to call if verification fails
     */

                expectedBuilder.put(entry.getKey().intersection(subRange), entry.getValue());
              }
            }

            ImmutableRangeMap<Integer, Integer> expected = expectedBuilder.build();
            assertEquals(expected, rangeMap.subRangeMap(subRange));
          }
        }
      }
    }
  }

  public void testSerialization() {