} finally {
                        latch.countDown();
                    }
                }).start();
            }

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

            if (exitValue != 0) {
                final StringBuilder out = new StringBuilder();
                if (processTimeout) {
                    out.append("Process is terminated due to ").append(timeout).append(" second exceeded.\n");
                }
                out.append("Exit Code: ").append(exitValue).append("\nOutput:\n").append(it.getOutput());
                throw new JobProcessingException(out.toString());
            }

	} else {
		srs.XferRateSml.addSize(sz, duration)
	}
}

func newSRStats() *SRStats {
	s := SRStats{
		M:               make(map[string]*SRStatus),
		movingAvgTicker: time.NewTicker(time.Second * 2),
	}
	go s.trackEWMA()
	return &s
}

func (sr *SRStats) trackEWMA() {
	for {
		select {
		case <-sr.movingAvgTicker.C:
			sr.updateMovingAvg()
		case <-GlobalContext.Done():

 * efficient `max-age=0` directive instead:
 *
 * ```java
 * Request request = new Request.Builder()
 *     .cacheControl(new CacheControl.Builder()
 *         .maxAge(0, TimeUnit.SECONDS)
 *         .build())
 *     .url("http://publicobject.com/helloworld.txt")
 *     .build();
 * ```
 *
 * ## Force a Cache Response
 *

    assertThat(Adapters.parseGeneralizedTime("19920622123421Z"))
      .isEqualTo(date("1992-06-22T12:34:21.000+0000").time)
  }

  @Disabled("fractional seconds are not implemented")
  @Test
  fun `parse generalized time with fractional seconds`() {
    assertThat(Adapters.parseGeneralizedTime("19920722132100.3Z"))
      .isEqualTo(date("1992-07-22T13:21:00.300+0000").time)
  }

    /**
     * Returns whether two strings are equal. If both are null, returns <code>true</code>.
     *
     * @param target1
     *            the first string
     * @param target2
     *            the second string
     * @return true if the strings are equal, false otherwise
     */
    public static boolean equals(final String target1, final String target2) {

            // this will run at most twice. The first time, the firstRun flag is turned off, and if the retry flag
            // is set on the first run, it will be turned off and not re-set on the second try. This is because the
            // only way the retry flag can be set is if ( firstRun == true ).
            while (firstRun || retry) {
                ChecksumObserver md5ChecksumObserver = null;

    @Test
    public void test_configuration_validation() throws Exception {
        // Test configuration without actual execution
        generator.setCommandTimeout(30000L); // 30 seconds
        generator.setCommandDestroyTimeout(5000L); // 5 seconds
        generator.setBaseDir(new File(System.getProperty("java.io.tmpdir")));
        generator.setCommandList(Arrays.asList("imagemagick", "convert", "${url}", "${outputFile}"));

            assertEquals(100L, SMBUtil.readInt8(buffer, 0));
            assertEquals(200L, SMBUtil.readInt8(buffer, 8));
            assertEquals(1, SMBUtil.readInt4(buffer, 16));

            // Verify second lock
            assertEquals(300L, SMBUtil.readInt8(buffer, 24));
            assertEquals(400L, SMBUtil.readInt8(buffer, 32));
            assertEquals(2, SMBUtil.readInt4(buffer, 40));

            when(mockEntry.getName()).thenReturn(null, "", " ");

            // Act & Assert
            assertNull(mockEntry.getName(), "first call returns null");
            assertEquals("", mockEntry.getName(), "second call returns empty");
            assertEquals(" ", mockEntry.getName(), "third call returns space");

            verify(mockEntry, times(3)).getName();
        }
    }