is IntValue -> KaConstantValue.KaIntConstantValue(value, sourcePsi = null)
        is LongValue -> KaConstantValue.KaLongConstantValue(value, sourcePsi = null)
        is ShortValue -> KaConstantValue.KaShortConstantValue(value, sourcePsi = null)
        is UByteValue -> KaConstantValue.KaUnsignedByteConstantValue(value.toUByte(), sourcePsi = null)

            setConfigFailurePolicy(prefix + "ConfigFailurePolicy")
            setListeners([prefix + "Listener"] as Set)
            setParallel(prefix + "Parallel")
            setThreadCount(intValue)
            getSuiteThreadPoolSize().set(intValue)
            setUseDefaultListeners(booleanValue)
            setThreadPoolFactoryClass(prefix + "ThreadPoolFactoryClass")
            setSuiteName(prefix + "SuiteName")

      at.set(x);
      assertEquals(Double.toString(x), at.toString());
    }
  }

  /** intValue returns current value. */
  public void testIntValue() {
    AtomicDouble at = new AtomicDouble();
    assertEquals(0, at.intValue());
    for (double x : VALUES) {
      at.set(x);
      assertEquals((int) x, at.intValue());
    }
  }

  /** longValue returns current value. */
  public void testLongValue() {

        verifyRoundtripOf({ MultiWriteObjectBean() }) { bean ->
            assertThat(
                bean.stringValue,
                equalTo("42")
            )
            assertThat(
                bean.intValue,
                equalTo(42)
            )
            assertThat(
                bean.writeOrder,
                equalTo(listOf("superclass", "subclass"))
            )
            assertThat(

	}
	ciphersIntSlice := make([]uint16, 0)
	possibleCiphers := allCiphers()
	for _, cipher := range cipherNames {
		intValue, ok := possibleCiphers[cipher]
		if !ok {
			return nil, fmt.Errorf("cipher suite %s not supported or doesn't exist", cipher)
		}
		ciphersIntSlice = append(ciphersIntSlice, intValue)
	}
	return ciphersIntSlice, nil

		if err != nil {
			return time.Duration(0), false
		}
		if node != nil && node.Annotations != nil {
			if value, ok := node.Annotations[v1.ObjectTTLAnnotationKey]; ok {
				if intValue, err := strconv.Atoi(value); err == nil {
					return time.Duration(intValue) * time.Second, true
				}
			}
		}
		return time.Duration(0), false
	}
}

func (s *objectStore) isObjectFresh(data *objectData) bool {

							// the actual port associated with the service is the `TargetPort` that reaches the sidecar *workload instances*.
							if tp := port.TargetPort.IntValue(); tp != 0 {
								servicePorts[uint32(tp)] = true
								if _, ok := portMapping[uint32(port.Port)]; !ok {
									portMapping[uint32(port.Port)] = uint32(tp)
								}
							} else {

    public void oneNullableArgThrows(@Nullable String s) {
      doThrow(s);
    }

    public void twoArg(String s, Integer i) {
      checkNotNull(s);
      i.intValue();
    }

    public void twoMixedArgs(String s, @Nullable Integer i) {
      checkNotNull(s);
    }

    public void twoMixedArgs(@Nullable Integer i, String s) {
      checkNotNull(s);
    }

          if (total >= Integer.MAX_VALUE) {
            break;
          }
        }
        result = size = Ints.saturatedCast(total);
      }
      return result.intValue();
    }

    @Override
    public UnmodifiableIterator<C> iterator() {
      return new AbstractIterator<C>() {
        final Iterator<Range<C>> rangeItr = ranges.iterator();

	floatValue           func(*state, *types.Type, float64) *ssa.Value
	intValue             func(*state, *types.Type, int64) *ssa.Value
	cutoff               uint64
}

var f32_u64 = f2uCvtTab{
	ltf:        ssa.OpLess32F,
	cvt2U:      ssa.OpCvt32Fto64,
	subf:       ssa.OpSub32F,
	or:         ssa.OpOr64,
	floatValue: (*state).constFloat32,
	intValue:   (*state).constInt64,
	cutoff:     1 << 63,
}