public double transform(double x) {
      return x * slope + yIntercept;
    }

    @Override
    public LinearTransformation inverse() {
      LinearTransformation result = inverse;
      return (result == null) ? inverse = createInverse() : result;
    }

    @Override
    public String toString() {
      return String.format("y = %g * x + %g", slope, yIntercept);
    }

    public T next() {
      Iterator<T> itr = stack.getLast(); // throws NSEE if empty
      T result = checkNotNull(itr.next());
      if (!itr.hasNext()) {
        stack.removeLast();
      }
      Iterator<T> childItr = children(result).iterator();
      if (childItr.hasNext()) {
        stack.addLast(childItr);
      }
      return result;
    }
  }

  /**

        // Test toString
        String result = fileStandardInfo.toString();

        // Verify string contains expected values
        assertTrue(result.contains("SmbQueryInfoStandard"));
        assertTrue(result.contains("allocationSize=" + expectedAllocationSize));
        assertTrue(result.contains("endOfFile=" + expectedEndOfFile));
        assertTrue(result.contains("numberOfLinks=" + expectedNumberOfLinks));

        String result = trans2FindNext2.toString();

        assertNotNull(result);
        assertTrue(result.contains("Trans2FindNext2"));
        assertTrue(result.contains("sid=" + TEST_SID));
        assertTrue(result.contains("searchCount=50"));
        assertTrue(result.contains("informationLevel=0x"));
        assertTrue(result.contains("resumeKey=0x" + Hexdump.toHexString(TEST_RESUME_KEY, 4)));

        FileBothDirectoryInfo e;

        int lastNameBufferIndex = bufferIndex + this.lastNameOffset;

        final FileBothDirectoryInfo[] results = new FileBothDirectoryInfo[getNumEntries()];
        for (int i = 0; i < getNumEntries(); i++) {
            results[i] = e = new FileBothDirectoryInfo(getConfig(), isUseUnicode());

            e.decode(buffer, bufferIndex, len);

            /*

                }))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a new synonym dictionary item.
     *
     * @param dictId the dictionary ID
     * @param body the request body containing synonym item information
     * @return JSON response with result status
     */
    // POST /api/admin/dict/synonym/setting/{dictId}
    @Execute

    super.setUp();
    timeLimiter = new FakeTimeLimiter();
  }

  public void testCallWithTimeout_propagatesReturnValue() throws Exception {
    String result =
        timeLimiter.callWithTimeout(Callables.returning(RETURN_VALUE), DELAY_MS, MILLISECONDS);

    assertThat(result).isEqualTo(RETURN_VALUE);
  }

  public void testCallWithTimeout_wrapsCheckedException() throws Exception {
    Exception exception = new SampleCheckedException();

            byte[] buffer = new byte[1024];
            int bytesRead = stream.read(buffer);
            assertEquals(data.length, bytesRead);

            String result = new String(buffer, 0, bytesRead, "UTF-8");
            assertEquals(testContent, result);
        }
    }

    @Test
    public void testFileBasedCacheGetInputStream() throws IOException {
        String testContent = "Hello, World!";

		{"config/iam/groups/foo/config.json", "config/iam/groups/", "config.json", "foo"},
	}
	for i, test := range specs {
		result := extractPathPrefixAndSuffix(test.path, test.prefix, test.suffix)
		if result != test.expected {
			t.Errorf("unexpected result on test[%v]: expected[%s] but had [%s]", i, test.expected, result)
		}
	}

                }
                return null;
            }
        }).when(smbFile).send(any(SmbComReadAndX.class), any(SmbComReadAndXResponse.class));

        int result = smbRandomAccessFile.read();
        assertEquals(42, result);
        assertEquals(1, smbRandomAccessFile.getFilePointer());
    }

    @Test
    void testReadEOF() throws SmbException {
        // Mock the read operation to return EOF