boolean result = propValue.equals(sysValue);

                if (reverseValue) {
                    return !result;
                } else {
                    return result;
                }
            } else {
                boolean result = sysValue != null && !sysValue.isEmpty();

                if (reverseName) {
                    return !result;
                } else {

func (JSONSerializer) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error) {
	result, err := json.Marshal(fieldValue)
	if string(result) == "null" {
		if field.TagSettings["NOT NULL"] != "" {
			return "", nil
		}
		return nil, err
	}
	return string(result), err
}

// UnixSecondSerializer json serializer
type UnixSecondSerializer struct{}

      length += array.length;
    }
    char[] result = new char[checkNoOverflow(length)];
    int pos = 0;
    for (char[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,

      length += array.length;
    }
    short[] result = new short[checkNoOverflow(length)];
    int pos = 0;
    for (short[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,

      length += array.length;
    }
    short[] result = new short[checkNoOverflow(length)];
    int pos = 0;
    for (short[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,

							}
						} else if result.Online {
							offline = prev.offlineDuration
						}
					}
					lastOnline = prev.lastOnline
					if result.Online {
						lastOnline = time.Now()
					}
					l := prev.latency
					l.update(time.Since(start))
					m[result.Endpoint.Host] = epHealth{
						Endpoint:        result.Endpoint.Host,
						Scheme:          result.Endpoint.Scheme,

      length += array.length;
    }
    int[] result = new int[checkNoOverflow(length)];
    int pos = 0;
    for (int[] array : arrays) {
      System.arraycopy(array, 0, result, pos, array.length);
      pos += array.length;
    }
    return result;
  }

  private static int checkNoOverflow(long result) {
    checkArgument(
        result == (int) result,

    // put it back together
    String result = Joiner.on('/').join(path);
    if (pathname.charAt(0) == '/') {
      result = "/" + result;
    }

    while (result.startsWith("/../")) {
      result = result.substring(3);
    }
    if (result.equals("/..")) {
      result = "/";
    } else if (result.isEmpty()) {
      result = ".";
    }

    return result;
  }

  /**

 */
internal class FailedPlan(
  e: Throwable,
) : RoutePlanner.Plan {
  val result = RoutePlanner.ConnectResult(plan = this, throwable = e)

  override val isReady = false

  override fun connectTcp() = result

  override fun connectTlsEtc() = result

  override fun handleSuccess() = error("unexpected call")

  override fun cancel() = error("unexpected cancel")

        var infoField = Smb2QueryInfoResponse.class.getDeclaredField("info");
        infoField.setAccessible(true);
        infoField.set(response, fileInfo);

        FileInternalInfo result = response.getInfo(FileInternalInfo.class);
        assertEquals(fileInfo, result);
    }

    @Test
    @DisplayName("Test getInfo with class type - incompatible class throws exception")
    void testGetInfoWithClassIncompatible() throws Exception {