+ session.getExecutionRootDirectory() + ")."
                            + " Please verify you invoked Maven from the correct directory.");
            throw new LifecycleExecutionException(messageBuilderFactory, mojoExecution, null, cause);
        }

        if (mojoDescriptor.isOnlineRequired() && session.isOffline()) {

  }

  @Test
  public void edgesConnecting_oneEdge() {
    addEdge(N1, N2, E12);
    assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12);
    // Passed nodes should be in the correct edge direction, first is the
    // source node and the second is the target node
    assertThat(network.edgesConnecting(N2, N1)).isEmpty();
  }

  @Test
  public void inEdges_oneEdge() {

        // When: Get challenge
        byte[] key = poolSpy.getChallenge(ctx, address);

        // Then: Should return server key
        assertArrayEquals(expectedKey, key, "Should return correct server key");
        verify(internal).ensureConnected();
    }

    @Test
    @DisplayName("Should wrap IOException in SmbException for getChallenge")
    void testGetChallengeIOException() throws Exception {

    Note over Server: Server interprets headers<br/>(if --forwarded-allow-ips is set)

    Server->>Proxy: HTTP Response<br/>with correct HTTPS URLs

    Proxy->>Client: HTTPS Response
```

	// and don't process the If-Modified-Since header.
	if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
		return false
	}

	// Check if the part number is correct.
	if opts.PartNumber > 1 {
		partFound := false
		for _, pi := range objInfo.Parts {
			if pi.Number == opts.PartNumber {
				partFound = true
				break
			}
		}
		if !partFound {

            assertEquals(4096, response.getChunkBytesWritten());
            assertEquals(12288, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should return correct bytes consumed")
        void testReturnBytesConsumed() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[100];
            byte[] responseData = createValidCopyChunkResponse(8, 16384, 131072);

        Model model = new Model(org.apache.maven.api.model.Model.newBuilder()
                .build(org.apache.maven.api.model.Build.newBuilder()
                        .sourceDirectory("correct")
                        .resources(List.of(org.apache.maven.api.model.Resource.newBuilder()
                                .directory("${project.build.sourceDirectory}")
                                .build()))

		if setDriveCount == 1 {
			cfg.RRS.Parity = 0
		}
	}

	// Validation is done after parsing both the storage classes. This is needed because we need one
	// storage class value to deduce the correct value of the other storage class.
	if err = validateParity(cfg.Standard.Parity, cfg.RRS.Parity, setDriveCount); err != nil {
		return Config{}, err
	}

	cfg.Optimize = env.Get(OptimizeEnv, kvs.Get(Optimize))

    assertCorrectSlice(100, 100, 0, 0);
    assertCorrectSlice(100, 100, 10, 0);
    assertCorrectSlice(100, 101, 10, 0);
  }

  /**
   * Tests that the default slice() behavior is correct when the source is sliced starting at an
   * offset that is greater than the current length of the source, a stream is then opened to that
   * source, and finally additional bytes are appended to the source before the stream is read.

            msg.decode_header(fragBuf);
            final int stub_frag_len = msg.length - 24;
            if (off + stub_frag_len > in.length) {
                // shouldn't happen if alloc_hint is correct or greater
                final byte[] tmp = new byte[off + stub_frag_len];
                System.arraycopy(in, 0, tmp, 0, off);
                in = tmp;
            }