return;
        }
        long expiration = -1;
        if (this.transportContext.getConfig().getNetbiosCachePolicy() != SmbConstants.FOREVER) {
            expiration = System.currentTimeMillis() + this.transportContext.getConfig().getNetbiosCachePolicy() * 1000;
        }
        cacheAddress(hostName, addr, expiration);
    }

    }

    /**
     * Test close(long) successfully.
     *
     * @throws CIFSException
     */
    @Test
    void testCloseWithLastWriteTime_success() throws CIFSException {
        long lastWriteTime = System.currentTimeMillis();
        smbFileHandle.close(lastWriteTime);
        verify(smbFileHandle, times(1)).close(lastWriteTime);
    }

    /**
     * Test close(long) when a CIFSException is thrown.
     *

            assertTrue(msg instanceof DcerpcMessage);
        }
    }

    @Nested
    @DisplayName("Edge case handling")
    class EdgeCases {

        @Test
        @DisplayName("should handle null system name")
        void testNullSystemNameDoesNotThrow() {
            // Arrange
            SamrPolicyHandle ph = createMockPolicyHandle();

            // Act & Assert

| `minio_node_io_read_bytes`                 | Total bytes read by the process from the underlying storage system, /proc/[pid]/io read_bytes.                  |
| `minio_node_io_wchar_bytes`                | Total bytes written by the process to the underlying storage system including page cache, /proc/[pid]/io wchar. |

# under the License.

maven.logger.defaultLogLevel=info
maven.logger.showDateTime=false
maven.logger.showThreadName=false
maven.logger.showLogName=false
maven.logger.logFile=System.out
maven.logger.cacheOutputStream=true
maven.logger.levelInBrackets=true
maven.logger.log.Sisu=info
maven.logger.warnLevelString=WARNING

# MNG-6181: mvn -X also prints all debug logging from HttpClient

  val capturedOut = ByteArrayOutputStream()

  private lateinit var executor: ExecutorService

  private lateinit var client: OkHttpClient

  @BeforeEach
  fun setUp() {
    platform.assumeLoom()
    assertThat(System.getProperty("jdk.tracePinnedThreads")).isNotEmpty()

    client =
      OkHttpClient
        .Builder()
        .trustMockServer()
        .dispatcher(Dispatcher(newVirtualThreadPerTaskExecutor()))
        .build()

      closedRequestBody.writeTo(Buffer())
    }
  }

  @Test
  fun testPathRead() {
    assertOnPath(content = "Hello") { path ->
      val requestBody = path.asRequestBody(FileSystem.SYSTEM)

      val buffer = Buffer()
      requestBody.writeTo(buffer)
      assertThat(buffer.readUtf8()).isEqualTo("Hello")
    }
  }

  private inline fun <T> assertOnFileDescriptor(

        if (shutdown && runningTasks == 0) {
          return true;
        } else if (nanos <= 0) {
          return false;
        } else {
          long now = System.nanoTime();
          NANOSECONDS.timedWait(lock, nanos);
          nanos -= System.nanoTime() - now; // subtract the actual time we waited
        }
      }
    }
  }

  /**

            return available;
        }
        if (generatorList != null && !generatorList.isEmpty()) {
            String path = System.getenv("PATH");
            if (path == null) {
                path = System.getenv("Path");
            }
            if (path == null) {
                path = System.getenv("path");
            }
            final List<String> pathList = new ArrayList<>();

********************************************************************************

## TensorFlow's Official CI and Build/Test Scripts

TensorFlow's official CI jobs run the scripts in this folder. Our internal CI
system, Kokoro, schedules our CI jobs by combining a build script with a file
from the `envs` directory that is filled with configuration options:

-   Nightly jobs (Run nightly on the `nightly` branch)