From 1addc23b231523c3bd5a219eb65de53578bae3ef Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Thu, 23 Jun 2022 08:45:29 +0300 Subject: [PATCH] Add range iteration tests for rangeUntil #KT-52932 --- .../FirBlackBoxCodegenTestGenerated.java | 720 +++++++++++++++++ .../box/ranges/expression/openRangeUntil.kt | 60 ++ .../expression/overflowZeroToMinValue.kt | 42 + .../box/ranges/literal/openRangeUntil.kt | 55 ++ .../ranges/literal/overflowZeroToMinValue.kt | 38 + .../expression/rangeUntil/emptyProgression.kt | 30 + .../rangeUntil/illegalStepNegative.kt | 27 + .../rangeUntil/illegalStepThenLegalStep.kt | 27 + .../expression/rangeUntil/illegalStepZero.kt | 27 + .../rangeUntil/legalStepThenIllegalStep.kt | 27 + .../nestedStep/stepOneThenStepOne.kt | 30 + .../rangeUntil/nestedStep/stepThenSameStep.kt | 30 + .../nestedStep/stepToSameLastThenStepOne.kt | 30 + .../stepToSameLastThenStepToSameLast.kt | 30 + .../stepToSameLastThenStepToSmallerLast.kt | 30 + .../stepToSmallerLastThenStepOne.kt | 30 + .../stepToSmallerLastThenStepToSameLast.kt | 30 + .../stepToSmallerLastThenStepToSmallerLast.kt | 30 + .../rangeUntil/reversed/reversedThenStep.kt | 30 + .../reversed/reversedThenStepThenReversed.kt | 30 + .../reversedThenStepThenReversedThenStep.kt | 30 + .../rangeUntil/reversed/stepThenReversed.kt | 30 + .../reversed/stepThenReversedThenStep.kt | 30 + .../stepThenReversedThenStepThenReversed.kt | 30 + .../rangeUntil/singleElementStepTwo.kt | 30 + .../stepped/expression/rangeUntil/stepOne.kt | 30 + .../rangeUntil/stepToOutsideRange.kt | 30 + .../expression/rangeUntil/stepToSameLast.kt | 30 + .../rangeUntil/stepToSmallerLast.kt | 30 + .../literal/rangeUntil/emptyProgression.kt | 27 + .../literal/rangeUntil/illegalStepNegative.kt | 26 + .../rangeUntil/illegalStepThenLegalStep.kt | 24 + .../literal/rangeUntil/illegalStepZero.kt | 26 + .../rangeUntil/legalStepThenIllegalStep.kt | 24 + .../nestedStep/stepOneThenStepOne.kt | 27 + .../rangeUntil/nestedStep/stepThenSameStep.kt | 27 + .../nestedStep/stepToSameLastThenStepOne.kt | 27 + .../stepToSameLastThenStepToSameLast.kt | 27 + .../stepToSameLastThenStepToSmallerLast.kt | 27 + .../stepToSmallerLastThenStepOne.kt | 27 + .../stepToSmallerLastThenStepToSameLast.kt | 27 + .../stepToSmallerLastThenStepToSmallerLast.kt | 27 + .../rangeUntil/reversed/reversedThenStep.kt | 27 + .../reversed/reversedThenStepThenReversed.kt | 27 + .../reversedThenStepThenReversedThenStep.kt | 27 + .../rangeUntil/reversed/stepThenReversed.kt | 27 + .../reversed/stepThenReversedThenStep.kt | 27 + .../stepThenReversedThenStepThenReversed.kt | 27 + .../rangeUntil/singleElementStepTwo.kt | 27 + .../stepped/literal/rangeUntil/stepOne.kt | 27 + .../literal/rangeUntil/stepToOutsideRange.kt | 27 + .../literal/rangeUntil/stepToSameLast.kt | 27 + .../literal/rangeUntil/stepToSmallerLast.kt | 27 + .../expression/rangeUntil/emptyProgression.kt | 23 + .../rangeUntil/illegalStepNegative.kt | 21 + .../rangeUntil/illegalStepThenLegalStep.kt | 21 + .../expression/rangeUntil/illegalStepZero.kt | 21 + .../rangeUntil/legalStepThenIllegalStep.kt | 21 + .../nestedStep/stepOneThenStepOne.kt | 23 + .../rangeUntil/nestedStep/stepThenSameStep.kt | 23 + .../nestedStep/stepToSameLastThenStepOne.kt | 23 + .../stepToSameLastThenStepToSameLast.kt | 23 + .../stepToSameLastThenStepToSmallerLast.kt | 23 + .../stepToSmallerLastThenStepOne.kt | 23 + .../stepToSmallerLastThenStepToSameLast.kt | 23 + .../stepToSmallerLastThenStepToSmallerLast.kt | 23 + .../rangeUntil/reversed/reversedThenStep.kt | 23 + .../reversed/reversedThenStepThenReversed.kt | 23 + .../reversedThenStepThenReversedThenStep.kt | 23 + .../rangeUntil/reversed/stepThenReversed.kt | 23 + .../reversed/stepThenReversedThenStep.kt | 23 + .../stepThenReversedThenStepThenReversed.kt | 23 + .../rangeUntil/singleElementStepTwo.kt | 23 + .../unsigned/expression/rangeUntil/stepOne.kt | 23 + .../rangeUntil/stepToOutsideRange.kt | 23 + .../expression/rangeUntil/stepToSameLast.kt | 23 + .../rangeUntil/stepToSmallerLast.kt | 23 + .../literal/rangeUntil/emptyProgression.kt | 21 + .../literal/rangeUntil/illegalStepNegative.kt | 21 + .../rangeUntil/illegalStepThenLegalStep.kt | 19 + .../literal/rangeUntil/illegalStepZero.kt | 21 + .../rangeUntil/legalStepThenIllegalStep.kt | 19 + .../nestedStep/stepOneThenStepOne.kt | 21 + .../rangeUntil/nestedStep/stepThenSameStep.kt | 21 + .../nestedStep/stepToSameLastThenStepOne.kt | 21 + .../stepToSameLastThenStepToSameLast.kt | 21 + .../stepToSameLastThenStepToSmallerLast.kt | 21 + .../stepToSmallerLastThenStepOne.kt | 21 + .../stepToSmallerLastThenStepToSameLast.kt | 21 + .../stepToSmallerLastThenStepToSmallerLast.kt | 21 + .../rangeUntil/reversed/reversedThenStep.kt | 21 + .../reversed/reversedThenStepThenReversed.kt | 21 + .../reversedThenStepThenReversedThenStep.kt | 21 + .../rangeUntil/reversed/stepThenReversed.kt | 21 + .../reversed/stepThenReversedThenStep.kt | 21 + .../stepThenReversedThenStepThenReversed.kt | 21 + .../rangeUntil/singleElementStepTwo.kt | 21 + .../unsigned/literal/rangeUntil/stepOne.kt | 21 + .../literal/rangeUntil/stepToOutsideRange.kt | 21 + .../literal/rangeUntil/stepToSameLast.kt | 21 + .../literal/rangeUntil/stepToSmallerLast.kt | 21 + .../unsigned/expression/openRangeUntil.kt | 50 ++ .../expression/overflowZeroToMinValue.kt | 42 + .../ranges/unsigned/literal/openRangeUntil.kt | 46 ++ .../literal/overflowZeroToMinValue.kt | 38 + .../codegen/BlackBoxCodegenTestGenerated.java | 720 +++++++++++++++++ .../IrBlackBoxCodegenTestGenerated.java | 720 +++++++++++++++++ .../LightAnalysisModeTestGenerated.java | 20 + .../tests/GenerateRangesCodegenTestData.java | 7 + .../GenerateSteppedRangesCodegenTestData.kt | 9 +- .../js/test/JsCodegenBoxTestGenerated.java | 696 ++++++++++++++++ .../test/ir/IrJsCodegenBoxTestGenerated.java | 720 +++++++++++++++++ .../IrCodegenBoxWasmTestGenerated.java | 656 +++++++++++++++ .../stdlib/test/ranges/RangeIterationTest.kt | 23 + .../NativeCodegenBoxTestGenerated.java | 744 ++++++++++++++++++ 115 files changed, 7797 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt create mode 100644 compiler/testData/codegen/box/ranges/literal/openRangeUntil.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/emptyProgression.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt create mode 100644 compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt create mode 100644 compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt create mode 100644 compiler/testData/codegen/box/ranges/unsigned/literal/openRangeUntil.kt diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java index b45438dedfe..779fa79fad4 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/test/runners/codegen/FirBlackBoxCodegenTestGenerated.java @@ -36256,6 +36256,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/ranges/expression/openRange.kt"); } + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt"); + } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { @@ -37276,6 +37282,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/ranges/literal/openRange.kt"); } + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/openRangeUntil.kt"); + } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { @@ -37851,6 +37863,180 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until") @TestDataPath("$PROJECT_ROOT") @@ -38497,6 +38683,180 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until") @TestDataPath("$PROJECT_ROOT") @@ -39152,6 +39512,180 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until") @TestDataPath("$PROJECT_ROOT") @@ -39798,6 +40332,180 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } } + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until") @TestDataPath("$PROJECT_ROOT") @@ -40137,6 +40845,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/ranges/unsigned/expression/openRange.kt"); } + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt"); + } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { @@ -40327,6 +41041,12 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/ranges/unsigned/literal/openRange.kt"); } + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/openRangeUntil.kt"); + } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { diff --git a/compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt b/compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt new file mode 100644 index 00000000000..6205d9e0acb --- /dev/null +++ b/compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt @@ -0,0 +1,60 @@ +// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT! +// !LANGUAGE: +RangeUntilOperator +// WITH_STDLIB + + + +@OptIn(ExperimentalStdlibApi::class) +fun box(): String { + val list1 = ArrayList() + val range1 = 1..<5 + for (i in range1) { + list1.add(i) + if (list1.size > 23) break + } + if (list1 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1..<5: $list1" + } + + val list2 = ArrayList() + val range2 = 1.toByte()..<5.toByte() + for (i in range2) { + list2.add(i) + if (list2.size > 23) break + } + if (list2 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1.toByte()..<5.toByte(): $list2" + } + + val list3 = ArrayList() + val range3 = 1.toShort()..<5.toShort() + for (i in range3) { + list3.add(i) + if (list3.size > 23) break + } + if (list3 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1.toShort()..<5.toShort(): $list3" + } + + val list4 = ArrayList() + val range4 = 1L..<5L + for (i in range4) { + list4.add(i) + if (list4.size > 23) break + } + if (list4 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1L..<5L: $list4" + } + + val list5 = ArrayList() + val range5 = 'a'..<'d' + for (i in range5) { + list5.add(i) + if (list5.size > 23) break + } + if (list5 != listOf('a', 'b', 'c')) { + return "Wrong elements for 'a'..<'d': $list5" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt b/compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt index d617dc252e3..c7f11d7b5bb 100644 --- a/compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt +++ b/compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt @@ -1,4 +1,5 @@ // Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT! +// !LANGUAGE: +RangeUntilOperator // WITH_STDLIB @@ -7,6 +8,7 @@ val MinB = Byte.MIN_VALUE val MinS = Short.MIN_VALUE val MinL = Long.MIN_VALUE +@OptIn(ExperimentalStdlibApi::class) fun box(): String { val list1 = ArrayList() val range1 = 0.toByte()..MinB step 3 @@ -88,5 +90,45 @@ fun box(): String { return "Wrong elements for 0L until MinL step 3: $list8" } + val list9 = ArrayList() + val range9 = 0.toByte().. 23) break + } + if (list9 != listOf()) { + return "Wrong elements for 0.toByte()..() + val range10 = 0.toShort().. 23) break + } + if (list10 != listOf()) { + return "Wrong elements for 0.toShort()..() + val range11 = 0.. 23) break + } + if (list11 != listOf()) { + return "Wrong elements for 0..() + val range12 = 0L.. 23) break + } + if (list12 != listOf()) { + return "Wrong elements for 0L..() + for (i in 1..<5) { + list1.add(i) + if (list1.size > 23) break + } + if (list1 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1..<5: $list1" + } + + val list2 = ArrayList() + for (i in 1.toByte()..<5.toByte()) { + list2.add(i) + if (list2.size > 23) break + } + if (list2 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1.toByte()..<5.toByte(): $list2" + } + + val list3 = ArrayList() + for (i in 1.toShort()..<5.toShort()) { + list3.add(i) + if (list3.size > 23) break + } + if (list3 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1.toShort()..<5.toShort(): $list3" + } + + val list4 = ArrayList() + for (i in 1L..<5L) { + list4.add(i) + if (list4.size > 23) break + } + if (list4 != listOf(1, 2, 3, 4)) { + return "Wrong elements for 1L..<5L: $list4" + } + + val list5 = ArrayList() + for (i in 'a'..<'d') { + list5.add(i) + if (list5.size > 23) break + } + if (list5 != listOf('a', 'b', 'c')) { + return "Wrong elements for 'a'..<'d': $list5" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt b/compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt index 9f32286d642..2e62701c8c8 100644 --- a/compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt +++ b/compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt @@ -1,4 +1,5 @@ // Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT! +// !LANGUAGE: +RangeUntilOperator // WITH_STDLIB @@ -7,6 +8,7 @@ val MinB = Byte.MIN_VALUE val MinS = Short.MIN_VALUE val MinL = Long.MIN_VALUE +@OptIn(ExperimentalStdlibApi::class) fun box(): String { val list1 = ArrayList() for (i in 0.toByte()..MinB step 3) { @@ -80,5 +82,41 @@ fun box(): String { return "Wrong elements for 0L until MinL step 3: $list8" } + val list9 = ArrayList() + for (i in 0.toByte().. 23) break + } + if (list9 != listOf()) { + return "Wrong elements for 0.toByte()..() + for (i in 0.toShort().. 23) break + } + if (list10 != listOf()) { + return "Wrong elements for 0.toShort()..() + for (i in 0.. 23) break + } + if (list11 != listOf()) { + return "Wrong elements for 0..() + for (i in 0L.. 23) break + } + if (list12 != listOf()) { + return "Wrong elements for 0L..() + val intProgression = 2..<2 + for (i in intProgression step 2) { + intList += i + } + assertTrue(intList.isEmpty()) + + val longList = mutableListOf() + val longProgression = 2L..<2L + for (i in longProgression step 2L) { + longList += i + } + assertTrue(longList.isEmpty()) + + val charList = mutableListOf() + val charProgression = 'b'..<'b' + for (i in charProgression step 2) { + charList += i + } + assertTrue(charList.isEmpty()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt new file mode 100644 index 00000000000..db9ba07b799 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val intProgression = 1..<8 + for (i in intProgression step -1) { + } + } + + assertFailsWith { + val longProgression = 1L..<8L + for (i in longProgression step -1L) { + } + } + + assertFailsWith { + val charProgression = 'a'..<'h' + for (i in charProgression step -1) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt new file mode 100644 index 00000000000..28f9564d90d --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val intProgression = 1..<8 + for (i in intProgression step 0 step 2) { + } + } + + assertFailsWith { + val longProgression = 1L..<8L + for (i in longProgression step 0L step 2L) { + } + } + + assertFailsWith { + val charProgression = 'a'..<'h' + for (i in charProgression step 0 step 2) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt new file mode 100644 index 00000000000..cf121fc23b9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val intProgression = 1..<8 + for (i in intProgression step 0) { + } + } + + assertFailsWith { + val longProgression = 1L..<8L + for (i in longProgression step 0L) { + } + } + + assertFailsWith { + val charProgression = 'a'..<'h' + for (i in charProgression step 0) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt new file mode 100644 index 00000000000..ae8f7c237fe --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val intProgression = 1..<8 + for (i in intProgression step 2 step 0) { + } + } + + assertFailsWith { + val longProgression = 1L..<8L + for (i in longProgression step 2L step 0L) { + } + } + + assertFailsWith { + val charProgression = 'a'..<'h' + for (i in charProgression step 2 step 0) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt new file mode 100644 index 00000000000..6a62aebff19 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<5 + for (i in intProgression step 1 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4), intList) + + val longList = mutableListOf() + val longProgression = 1L..<5L + for (i in longProgression step 1L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'e' + for (i in charProgression step 1 step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt new file mode 100644 index 00000000000..44e0581a52c --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<9 + for (i in intProgression step 2 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + val longProgression = 1L..<9L + for (i in longProgression step 2L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'i' + for (i in charProgression step 2 step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt new file mode 100644 index 00000000000..747552334f1 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<6 + for (i in intProgression step 2 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4, 5), intList) + + val longList = mutableListOf() + val longProgression = 1L..<6L + for (i in longProgression step 2L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'f' + for (i in charProgression step 2 step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt new file mode 100644 index 00000000000..b877caf3917 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<8 + for (i in intProgression step 3 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + val longProgression = 1L..<8L + for (i in longProgression step 3L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'h' + for (i in charProgression step 3 step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..81d5d5bc7d4 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<11 + for (i in intProgression step 3 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7, 9), intList) + + val longList = mutableListOf() + val longProgression = 1L..<11L + for (i in longProgression step 3L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L, 9L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'k' + for (i in charProgression step 3 step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g', 'i'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt new file mode 100644 index 00000000000..a0604807bc5 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<7 + for (i in intProgression step 2 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4, 5), intList) + + val longList = mutableListOf() + val longProgression = 1L..<7L + for (i in longProgression step 2L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'g' + for (i in charProgression step 2 step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt new file mode 100644 index 00000000000..1cb204b5ffb --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<9 + for (i in intProgression step 2 step 3) { + intList += i + } + assertEquals(listOf(1, 4, 7), intList) + + val longList = mutableListOf() + val longProgression = 1L..<9L + for (i in longProgression step 2L step 3L) { + longList += i + } + assertEquals(listOf(1L, 4L, 7L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'i' + for (i in charProgression step 2 step 3) { + charList += i + } + assertEquals(listOf('a', 'd', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..4f02f2ebde7 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<11 + for (i in intProgression step 2 step 3) { + intList += i + } + assertEquals(listOf(1, 4, 7), intList) + + val longList = mutableListOf() + val longProgression = 1L..<11L + for (i in longProgression step 2L step 3L) { + longList += i + } + assertEquals(listOf(1L, 4L, 7L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'k' + for (i in charProgression step 2 step 3) { + charList += i + } + assertEquals(listOf('a', 'd', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt new file mode 100644 index 00000000000..04c1af78a0a --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<9 + for (i in intProgression.reversed() step 2) { + intList += i + } + assertEquals(listOf(8, 6, 4, 2), intList) + + val longList = mutableListOf() + val longProgression = 1L..<9L + for (i in longProgression.reversed() step 2L) { + longList += i + } + assertEquals(listOf(8L, 6L, 4L, 2L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'i' + for (i in charProgression.reversed() step 2) { + charList += i + } + assertEquals(listOf('h', 'f', 'd', 'b'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt new file mode 100644 index 00000000000..7290c86a79a --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<9 + for (i in (intProgression.reversed() step 2).reversed()) { + intList += i + } + assertEquals(listOf(2, 4, 6, 8), intList) + + val longList = mutableListOf() + val longProgression = 1L..<9L + for (i in (longProgression.reversed() step 2L).reversed()) { + longList += i + } + assertEquals(listOf(2L, 4L, 6L, 8L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'i' + for (i in (charProgression.reversed() step 2).reversed()) { + charList += i + } + assertEquals(listOf('b', 'd', 'f', 'h'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt new file mode 100644 index 00000000000..7b525c6a5e7 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<11 + for (i in (intProgression.reversed() step 2).reversed() step 3) { + intList += i + } + assertEquals(listOf(2, 5, 8), intList) + + val longList = mutableListOf() + val longProgression = 1L..<11L + for (i in (longProgression.reversed() step 2L).reversed() step 3L) { + longList += i + } + assertEquals(listOf(2L, 5L, 8L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'k' + for (i in (charProgression.reversed() step 2).reversed() step 3) { + charList += i + } + assertEquals(listOf('b', 'e', 'h'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt new file mode 100644 index 00000000000..3565b8016db --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<9 + for (i in (intProgression step 2).reversed()) { + intList += i + } + assertEquals(listOf(7, 5, 3, 1), intList) + + val longList = mutableListOf() + val longProgression = 1L..<9L + for (i in (longProgression step 2L).reversed()) { + longList += i + } + assertEquals(listOf(7L, 5L, 3L, 1L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'i' + for (i in (charProgression step 2).reversed()) { + charList += i + } + assertEquals(listOf('g', 'e', 'c', 'a'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt new file mode 100644 index 00000000000..90ae3892703 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<11 + for (i in (intProgression step 2).reversed() step 3) { + intList += i + } + assertEquals(listOf(9, 6, 3), intList) + + val longList = mutableListOf() + val longProgression = 1L..<11L + for (i in (longProgression step 2L).reversed() step 3L) { + longList += i + } + assertEquals(listOf(9L, 6L, 3L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'k' + for (i in (charProgression step 2).reversed() step 3) { + charList += i + } + assertEquals(listOf('i', 'f', 'c'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt new file mode 100644 index 00000000000..3461ec6e241 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<11 + for (i in ((intProgression step 2).reversed() step 3).reversed()) { + intList += i + } + assertEquals(listOf(3, 6, 9), intList) + + val longList = mutableListOf() + val longProgression = 1L..<11L + for (i in ((longProgression step 2L).reversed() step 3L).reversed()) { + longList += i + } + assertEquals(listOf(3L, 6L, 9L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'k' + for (i in ((charProgression step 2).reversed() step 3).reversed()) { + charList += i + } + assertEquals(listOf('c', 'f', 'i'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt new file mode 100644 index 00000000000..7747b9a06d6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<2 + for (i in intProgression step 2) { + intList += i + } + assertEquals(listOf(1), intList) + + val longList = mutableListOf() + val longProgression = 1L..<2L + for (i in longProgression step 2L) { + longList += i + } + assertEquals(listOf(1L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'b' + for (i in charProgression step 2) { + charList += i + } + assertEquals(listOf('a'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt new file mode 100644 index 00000000000..32b7fb3d4cb --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<5 + for (i in intProgression step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4), intList) + + val longList = mutableListOf() + val longProgression = 1L..<5L + for (i in longProgression step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'e' + for (i in charProgression step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt new file mode 100644 index 00000000000..eb31e054c4c --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<8 + for (i in intProgression step 7) { + intList += i + } + assertEquals(listOf(1), intList) + + val longList = mutableListOf() + val longProgression = 1L..<8L + for (i in longProgression step 7L) { + longList += i + } + assertEquals(listOf(1L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'h' + for (i in charProgression step 7) { + charList += i + } + assertEquals(listOf('a'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt new file mode 100644 index 00000000000..8bcabe06581 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<8 + for (i in intProgression step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + val longProgression = 1L..<8L + for (i in longProgression step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'h' + for (i in charProgression step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt new file mode 100644 index 00000000000..37b2f6f3f78 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt @@ -0,0 +1,30 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + val intProgression = 1..<9 + for (i in intProgression step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + val longProgression = 1L..<9L + for (i in longProgression step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + val charProgression = 'a'..<'i' + for (i in charProgression step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt new file mode 100644 index 00000000000..e5b462adbf2 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 2..<2 step 2) { + intList += i + } + assertTrue(intList.isEmpty()) + + val longList = mutableListOf() + for (i in 2L..<2L step 2L) { + longList += i + } + assertTrue(longList.isEmpty()) + + val charList = mutableListOf() + for (i in 'b'..<'b' step 2) { + charList += i + } + assertTrue(charList.isEmpty()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt new file mode 100644 index 00000000000..71568b992b6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt @@ -0,0 +1,26 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// KT-34166: Translation of loop over literal completely removes the validation of step +// DONT_TARGET_EXACT_BACKEND: JS +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1..<8 step -1) { + } + } + + assertFailsWith { + for (i in 1L..<8L step -1L) { + } + } + + assertFailsWith { + for (i in 'a'..<'h' step -1) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt new file mode 100644 index 00000000000..307a572cd6c --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt @@ -0,0 +1,24 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1..<8 step 0 step 2) { + } + } + + assertFailsWith { + for (i in 1L..<8L step 0L step 2L) { + } + } + + assertFailsWith { + for (i in 'a'..<'h' step 0 step 2) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt new file mode 100644 index 00000000000..f1b1f625bfc --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt @@ -0,0 +1,26 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// KT-34166: Translation of loop over literal completely removes the validation of step +// DONT_TARGET_EXACT_BACKEND: JS +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1..<8 step 0) { + } + } + + assertFailsWith { + for (i in 1L..<8L step 0L) { + } + } + + assertFailsWith { + for (i in 'a'..<'h' step 0) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt new file mode 100644 index 00000000000..07d1525f0e2 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt @@ -0,0 +1,24 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1..<8 step 2 step 0) { + } + } + + assertFailsWith { + for (i in 1L..<8L step 2L step 0L) { + } + } + + assertFailsWith { + for (i in 'a'..<'h' step 2 step 0) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt new file mode 100644 index 00000000000..b8048394836 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<5 step 1 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4), intList) + + val longList = mutableListOf() + for (i in 1L..<5L step 1L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'e' step 1 step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt new file mode 100644 index 00000000000..45f13974fa6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<9 step 2 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + for (i in 1L..<9L step 2L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'i' step 2 step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt new file mode 100644 index 00000000000..48b06784065 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<6 step 2 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4, 5), intList) + + val longList = mutableListOf() + for (i in 1L..<6L step 2L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'f' step 2 step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt new file mode 100644 index 00000000000..c550e7b8b92 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<8 step 3 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + for (i in 1L..<8L step 3L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'h' step 3 step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..6a7f86a2d59 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<11 step 3 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7, 9), intList) + + val longList = mutableListOf() + for (i in 1L..<11L step 3L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L, 9L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'k' step 3 step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g', 'i'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt new file mode 100644 index 00000000000..30ee37d6fd5 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<7 step 2 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4, 5), intList) + + val longList = mutableListOf() + for (i in 1L..<7L step 2L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L, 5L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'g' step 2 step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd', 'e'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt new file mode 100644 index 00000000000..75f64e907bf --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<9 step 2 step 3) { + intList += i + } + assertEquals(listOf(1, 4, 7), intList) + + val longList = mutableListOf() + for (i in 1L..<9L step 2L step 3L) { + longList += i + } + assertEquals(listOf(1L, 4L, 7L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'i' step 2 step 3) { + charList += i + } + assertEquals(listOf('a', 'd', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..c0fbcf15d09 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<11 step 2 step 3) { + intList += i + } + assertEquals(listOf(1, 4, 7), intList) + + val longList = mutableListOf() + for (i in 1L..<11L step 2L step 3L) { + longList += i + } + assertEquals(listOf(1L, 4L, 7L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'k' step 2 step 3) { + charList += i + } + assertEquals(listOf('a', 'd', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt new file mode 100644 index 00000000000..dd74a34fd8a --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in (1..<9).reversed() step 2) { + intList += i + } + assertEquals(listOf(8, 6, 4, 2), intList) + + val longList = mutableListOf() + for (i in (1L..<9L).reversed() step 2L) { + longList += i + } + assertEquals(listOf(8L, 6L, 4L, 2L), longList) + + val charList = mutableListOf() + for (i in ('a'..<'i').reversed() step 2) { + charList += i + } + assertEquals(listOf('h', 'f', 'd', 'b'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt new file mode 100644 index 00000000000..05d35a04432 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in ((1..<9).reversed() step 2).reversed()) { + intList += i + } + assertEquals(listOf(2, 4, 6, 8), intList) + + val longList = mutableListOf() + for (i in ((1L..<9L).reversed() step 2L).reversed()) { + longList += i + } + assertEquals(listOf(2L, 4L, 6L, 8L), longList) + + val charList = mutableListOf() + for (i in (('a'..<'i').reversed() step 2).reversed()) { + charList += i + } + assertEquals(listOf('b', 'd', 'f', 'h'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt new file mode 100644 index 00000000000..434b550cda6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in ((1..<11).reversed() step 2).reversed() step 3) { + intList += i + } + assertEquals(listOf(2, 5, 8), intList) + + val longList = mutableListOf() + for (i in ((1L..<11L).reversed() step 2L).reversed() step 3L) { + longList += i + } + assertEquals(listOf(2L, 5L, 8L), longList) + + val charList = mutableListOf() + for (i in (('a'..<'k').reversed() step 2).reversed() step 3) { + charList += i + } + assertEquals(listOf('b', 'e', 'h'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt new file mode 100644 index 00000000000..46e8a6c83dd --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in (1..<9 step 2).reversed()) { + intList += i + } + assertEquals(listOf(7, 5, 3, 1), intList) + + val longList = mutableListOf() + for (i in (1L..<9L step 2L).reversed()) { + longList += i + } + assertEquals(listOf(7L, 5L, 3L, 1L), longList) + + val charList = mutableListOf() + for (i in ('a'..<'i' step 2).reversed()) { + charList += i + } + assertEquals(listOf('g', 'e', 'c', 'a'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt new file mode 100644 index 00000000000..1c8fe6d5007 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in (1..<11 step 2).reversed() step 3) { + intList += i + } + assertEquals(listOf(9, 6, 3), intList) + + val longList = mutableListOf() + for (i in (1L..<11L step 2L).reversed() step 3L) { + longList += i + } + assertEquals(listOf(9L, 6L, 3L), longList) + + val charList = mutableListOf() + for (i in ('a'..<'k' step 2).reversed() step 3) { + charList += i + } + assertEquals(listOf('i', 'f', 'c'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt new file mode 100644 index 00000000000..1ab4af441f9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in ((1..<11 step 2).reversed() step 3).reversed()) { + intList += i + } + assertEquals(listOf(3, 6, 9), intList) + + val longList = mutableListOf() + for (i in ((1L..<11L step 2L).reversed() step 3L).reversed()) { + longList += i + } + assertEquals(listOf(3L, 6L, 9L), longList) + + val charList = mutableListOf() + for (i in (('a'..<'k' step 2).reversed() step 3).reversed()) { + charList += i + } + assertEquals(listOf('c', 'f', 'i'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt new file mode 100644 index 00000000000..a09aa0fbab3 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<2 step 2) { + intList += i + } + assertEquals(listOf(1), intList) + + val longList = mutableListOf() + for (i in 1L..<2L step 2L) { + longList += i + } + assertEquals(listOf(1L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'b' step 2) { + charList += i + } + assertEquals(listOf('a'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt new file mode 100644 index 00000000000..00475a84555 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<5 step 1) { + intList += i + } + assertEquals(listOf(1, 2, 3, 4), intList) + + val longList = mutableListOf() + for (i in 1L..<5L step 1L) { + longList += i + } + assertEquals(listOf(1L, 2L, 3L, 4L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'e' step 1) { + charList += i + } + assertEquals(listOf('a', 'b', 'c', 'd'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt new file mode 100644 index 00000000000..bb6e0be7034 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<8 step 7) { + intList += i + } + assertEquals(listOf(1), intList) + + val longList = mutableListOf() + for (i in 1L..<8L step 7L) { + longList += i + } + assertEquals(listOf(1L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'h' step 7) { + charList += i + } + assertEquals(listOf('a'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt new file mode 100644 index 00000000000..5640b6da6e9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<8 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + for (i in 1L..<8L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'h' step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt new file mode 100644 index 00000000000..7049bd65c67 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt @@ -0,0 +1,27 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val intList = mutableListOf() + for (i in 1..<9 step 2) { + intList += i + } + assertEquals(listOf(1, 3, 5, 7), intList) + + val longList = mutableListOf() + for (i in 1L..<9L step 2L) { + longList += i + } + assertEquals(listOf(1L, 3L, 5L, 7L), longList) + + val charList = mutableListOf() + for (i in 'a'..<'i' step 2) { + charList += i + } + assertEquals(listOf('a', 'c', 'e', 'g'), charList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt new file mode 100644 index 00000000000..7e22ffd3b8a --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 2u..<2u + for (i in uintProgression step 2) { + uintList += i + } + assertTrue(uintList.isEmpty()) + + val ulongList = mutableListOf() + val ulongProgression = 2uL..<2uL + for (i in ulongProgression step 2L) { + ulongList += i + } + assertTrue(ulongList.isEmpty()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt new file mode 100644 index 00000000000..e050fb77c6b --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val uintProgression = 1u..<8u + for (i in uintProgression step -1) { + } + } + + assertFailsWith { + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step -1L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt new file mode 100644 index 00000000000..34d7c9693ca --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val uintProgression = 1u..<8u + for (i in uintProgression step 0 step 2) { + } + } + + assertFailsWith { + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step 0L step 2L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt new file mode 100644 index 00000000000..c8a8c5372b6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val uintProgression = 1u..<8u + for (i in uintProgression step 0) { + } + } + + assertFailsWith { + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step 0L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt new file mode 100644 index 00000000000..1f1baca7758 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + val uintProgression = 1u..<8u + for (i in uintProgression step 2 step 0) { + } + } + + assertFailsWith { + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step 2L step 0L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt new file mode 100644 index 00000000000..5b31eb69d94 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<5u + for (i in uintProgression step 1 step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<5uL + for (i in ulongProgression step 1L step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt new file mode 100644 index 00000000000..57045ce2b0f --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<9u + for (i in uintProgression step 2 step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<9uL + for (i in ulongProgression step 2L step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt new file mode 100644 index 00000000000..6477abfbdaf --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<6u + for (i in uintProgression step 2 step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<6uL + for (i in ulongProgression step 2L step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt new file mode 100644 index 00000000000..fb58f4ba3ad --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<8u + for (i in uintProgression step 3 step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step 3L step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..ab1c367bd83 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<11u + for (i in uintProgression step 3 step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u, 9u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<11uL + for (i in ulongProgression step 3L step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL, 9uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt new file mode 100644 index 00000000000..8c6bfee68b9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<7u + for (i in uintProgression step 2 step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<7uL + for (i in ulongProgression step 2L step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt new file mode 100644 index 00000000000..43b3debbd23 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<9u + for (i in uintProgression step 2 step 3) { + uintList += i + } + assertEquals(listOf(1u, 4u, 7u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<9uL + for (i in ulongProgression step 2L step 3L) { + ulongList += i + } + assertEquals(listOf(1uL, 4uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..8e38a1772a9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<11u + for (i in uintProgression step 2 step 3) { + uintList += i + } + assertEquals(listOf(1u, 4u, 7u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<11uL + for (i in ulongProgression step 2L step 3L) { + ulongList += i + } + assertEquals(listOf(1uL, 4uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt new file mode 100644 index 00000000000..b495d9559d9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<9u + for (i in uintProgression.reversed() step 2) { + uintList += i + } + assertEquals(listOf(8u, 6u, 4u, 2u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<9uL + for (i in ulongProgression.reversed() step 2L) { + ulongList += i + } + assertEquals(listOf(8uL, 6uL, 4uL, 2uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt new file mode 100644 index 00000000000..054bfd02e52 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<9u + for (i in (uintProgression.reversed() step 2).reversed()) { + uintList += i + } + assertEquals(listOf(2u, 4u, 6u, 8u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<9uL + for (i in (ulongProgression.reversed() step 2L).reversed()) { + ulongList += i + } + assertEquals(listOf(2uL, 4uL, 6uL, 8uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt new file mode 100644 index 00000000000..3b5d88a367b --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<11u + for (i in (uintProgression.reversed() step 2).reversed() step 3) { + uintList += i + } + assertEquals(listOf(2u, 5u, 8u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<11uL + for (i in (ulongProgression.reversed() step 2L).reversed() step 3L) { + ulongList += i + } + assertEquals(listOf(2uL, 5uL, 8uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt new file mode 100644 index 00000000000..84580381d67 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<9u + for (i in (uintProgression step 2).reversed()) { + uintList += i + } + assertEquals(listOf(7u, 5u, 3u, 1u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<9uL + for (i in (ulongProgression step 2L).reversed()) { + ulongList += i + } + assertEquals(listOf(7uL, 5uL, 3uL, 1uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt new file mode 100644 index 00000000000..686d825814f --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<11u + for (i in (uintProgression step 2).reversed() step 3) { + uintList += i + } + assertEquals(listOf(9u, 6u, 3u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<11uL + for (i in (ulongProgression step 2L).reversed() step 3L) { + ulongList += i + } + assertEquals(listOf(9uL, 6uL, 3uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt new file mode 100644 index 00000000000..bf222fc85ad --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<11u + for (i in ((uintProgression step 2).reversed() step 3).reversed()) { + uintList += i + } + assertEquals(listOf(3u, 6u, 9u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<11uL + for (i in ((ulongProgression step 2L).reversed() step 3L).reversed()) { + ulongList += i + } + assertEquals(listOf(3uL, 6uL, 9uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt new file mode 100644 index 00000000000..c4e9333f4b2 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<2u + for (i in uintProgression step 2) { + uintList += i + } + assertEquals(listOf(1u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<2uL + for (i in ulongProgression step 2L) { + ulongList += i + } + assertEquals(listOf(1uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt new file mode 100644 index 00000000000..0a29e41ff67 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<5u + for (i in uintProgression step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<5uL + for (i in ulongProgression step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt new file mode 100644 index 00000000000..300355bbecc --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<8u + for (i in uintProgression step 7) { + uintList += i + } + assertEquals(listOf(1u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step 7L) { + ulongList += i + } + assertEquals(listOf(1uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt new file mode 100644 index 00000000000..1bffa1c1e48 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<8u + for (i in uintProgression step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<8uL + for (i in ulongProgression step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt new file mode 100644 index 00000000000..7c19ee2eca6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt @@ -0,0 +1,23 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + val uintProgression = 1u..<9u + for (i in uintProgression step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + val ulongProgression = 1uL..<9uL + for (i in ulongProgression step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt new file mode 100644 index 00000000000..f7237085594 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 2u..<2u step 2) { + uintList += i + } + assertTrue(uintList.isEmpty()) + + val ulongList = mutableListOf() + for (i in 2uL..<2uL step 2L) { + ulongList += i + } + assertTrue(ulongList.isEmpty()) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt new file mode 100644 index 00000000000..8b635e41768 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// KT-34166: Translation of loop over literal completely removes the validation of step +// DONT_TARGET_EXACT_BACKEND: JS +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1u..<8u step -1) { + } + } + + assertFailsWith { + for (i in 1uL..<8uL step -1L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt new file mode 100644 index 00000000000..7e381a0628b --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt @@ -0,0 +1,19 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1u..<8u step 0 step 2) { + } + } + + assertFailsWith { + for (i in 1uL..<8uL step 0L step 2L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt new file mode 100644 index 00000000000..661d08c1ae5 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// KT-34166: Translation of loop over literal completely removes the validation of step +// DONT_TARGET_EXACT_BACKEND: JS +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1u..<8u step 0) { + } + } + + assertFailsWith { + for (i in 1uL..<8uL step 0L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt new file mode 100644 index 00000000000..d52f58ecf1e --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt @@ -0,0 +1,19 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + assertFailsWith { + for (i in 1u..<8u step 2 step 0) { + } + } + + assertFailsWith { + for (i in 1uL..<8uL step 2L step 0L) { + } + } + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt new file mode 100644 index 00000000000..702d3be0ae0 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<5u step 1 step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<5uL step 1L step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt new file mode 100644 index 00000000000..b36803ed636 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<9u step 2 step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<9uL step 2L step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt new file mode 100644 index 00000000000..2ecdf66c816 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<6u step 2 step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<6uL step 2L step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt new file mode 100644 index 00000000000..fbf4248d882 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<8u step 3 step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<8uL step 3L step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..0766e484ab9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<11u step 3 step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u, 9u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<11uL step 3L step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL, 9uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt new file mode 100644 index 00000000000..1f584bbdc64 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<7u step 2 step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u, 5u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<7uL step 2L step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL, 5uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt new file mode 100644 index 00000000000..62e48370314 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<9u step 2 step 3) { + uintList += i + } + assertEquals(listOf(1u, 4u, 7u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<9uL step 2L step 3L) { + ulongList += i + } + assertEquals(listOf(1uL, 4uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt new file mode 100644 index 00000000000..74b58b0634d --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<11u step 2 step 3) { + uintList += i + } + assertEquals(listOf(1u, 4u, 7u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<11uL step 2L step 3L) { + ulongList += i + } + assertEquals(listOf(1uL, 4uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt new file mode 100644 index 00000000000..34b1dcbaef6 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in (1u..<9u).reversed() step 2) { + uintList += i + } + assertEquals(listOf(8u, 6u, 4u, 2u), uintList) + + val ulongList = mutableListOf() + for (i in (1uL..<9uL).reversed() step 2L) { + ulongList += i + } + assertEquals(listOf(8uL, 6uL, 4uL, 2uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt new file mode 100644 index 00000000000..fe79d18afe9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in ((1u..<9u).reversed() step 2).reversed()) { + uintList += i + } + assertEquals(listOf(2u, 4u, 6u, 8u), uintList) + + val ulongList = mutableListOf() + for (i in ((1uL..<9uL).reversed() step 2L).reversed()) { + ulongList += i + } + assertEquals(listOf(2uL, 4uL, 6uL, 8uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt new file mode 100644 index 00000000000..59a586ce8a9 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in ((1u..<11u).reversed() step 2).reversed() step 3) { + uintList += i + } + assertEquals(listOf(2u, 5u, 8u), uintList) + + val ulongList = mutableListOf() + for (i in ((1uL..<11uL).reversed() step 2L).reversed() step 3L) { + ulongList += i + } + assertEquals(listOf(2uL, 5uL, 8uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt new file mode 100644 index 00000000000..931b68bea2e --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in (1u..<9u step 2).reversed()) { + uintList += i + } + assertEquals(listOf(7u, 5u, 3u, 1u), uintList) + + val ulongList = mutableListOf() + for (i in (1uL..<9uL step 2L).reversed()) { + ulongList += i + } + assertEquals(listOf(7uL, 5uL, 3uL, 1uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt new file mode 100644 index 00000000000..66352e0aa38 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in (1u..<11u step 2).reversed() step 3) { + uintList += i + } + assertEquals(listOf(9u, 6u, 3u), uintList) + + val ulongList = mutableListOf() + for (i in (1uL..<11uL step 2L).reversed() step 3L) { + ulongList += i + } + assertEquals(listOf(9uL, 6uL, 3uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt new file mode 100644 index 00000000000..a70f7a2c85c --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in ((1u..<11u step 2).reversed() step 3).reversed()) { + uintList += i + } + assertEquals(listOf(3u, 6u, 9u), uintList) + + val ulongList = mutableListOf() + for (i in ((1uL..<11uL step 2L).reversed() step 3L).reversed()) { + ulongList += i + } + assertEquals(listOf(3uL, 6uL, 9uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt new file mode 100644 index 00000000000..cc6db96a5e0 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<2u step 2) { + uintList += i + } + assertEquals(listOf(1u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<2uL step 2L) { + ulongList += i + } + assertEquals(listOf(1uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt new file mode 100644 index 00000000000..3d4a4ecfe21 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<5u step 1) { + uintList += i + } + assertEquals(listOf(1u, 2u, 3u, 4u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<5uL step 1L) { + ulongList += i + } + assertEquals(listOf(1uL, 2uL, 3uL, 4uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt new file mode 100644 index 00000000000..05f9c7ff790 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<8u step 7) { + uintList += i + } + assertEquals(listOf(1u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<8uL step 7L) { + ulongList += i + } + assertEquals(listOf(1uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt new file mode 100644 index 00000000000..7dee55f1b57 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<8u step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<8uL step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt new file mode 100644 index 00000000000..4ef2473c939 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt @@ -0,0 +1,21 @@ +// Auto-generated by GenerateSteppedRangesCodegenTestData. Do not edit! +// WITH_STDLIB +// !LANGUAGE: +RangeUntilOperator +@file:OptIn(ExperimentalStdlibApi::class) +import kotlin.test.* + +fun box(): String { + val uintList = mutableListOf() + for (i in 1u..<9u step 2) { + uintList += i + } + assertEquals(listOf(1u, 3u, 5u, 7u), uintList) + + val ulongList = mutableListOf() + for (i in 1uL..<9uL step 2L) { + ulongList += i + } + assertEquals(listOf(1uL, 3uL, 5uL, 7uL), ulongList) + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt b/compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt new file mode 100644 index 00000000000..9ce66380603 --- /dev/null +++ b/compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt @@ -0,0 +1,50 @@ +// Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT! +// !LANGUAGE: +RangeUntilOperator +// WITH_STDLIB + + + +@OptIn(ExperimentalStdlibApi::class) +fun box(): String { + val list1 = ArrayList() + val range1 = 1u..<5u + for (i in range1) { + list1.add(i) + if (list1.size > 23) break + } + if (list1 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1u..<5u: $list1" + } + + val list2 = ArrayList() + val range2 = 1u.toUByte()..<5u.toUByte() + for (i in range2) { + list2.add(i) + if (list2.size > 23) break + } + if (list2 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1u.toUByte()..<5u.toUByte(): $list2" + } + + val list3 = ArrayList() + val range3 = 1u.toUShort()..<5u.toUShort() + for (i in range3) { + list3.add(i) + if (list3.size > 23) break + } + if (list3 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1u.toUShort()..<5u.toUShort(): $list3" + } + + val list4 = ArrayList() + val range4 = 1uL..<5uL + for (i in range4) { + list4.add(i) + if (list4.size > 23) break + } + if (list4 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1uL..<5uL: $list4" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroToMinValue.kt b/compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroToMinValue.kt index 8acb74e1602..f9c9f29b559 100644 --- a/compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroToMinValue.kt +++ b/compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroToMinValue.kt @@ -1,4 +1,5 @@ // Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT! +// !LANGUAGE: +RangeUntilOperator // WITH_STDLIB @@ -7,6 +8,7 @@ val MinUB = UByte.MIN_VALUE val MinUS = UShort.MIN_VALUE val MinUL = ULong.MIN_VALUE +@OptIn(ExperimentalStdlibApi::class) fun box(): String { val list1 = ArrayList() val range1 = 1u.toUByte()..MinUB step 3 @@ -88,5 +90,45 @@ fun box(): String { return "Wrong elements for 1uL until MinUL step 3: $list8" } + val list9 = ArrayList() + val range9 = 1u.toUByte().. 23) break + } + if (list9 != listOf()) { + return "Wrong elements for 1u.toUByte()..() + val range10 = 1u.toUShort().. 23) break + } + if (list10 != listOf()) { + return "Wrong elements for 1u.toUShort()..() + val range11 = 1u.. 23) break + } + if (list11 != listOf()) { + return "Wrong elements for 1u..() + val range12 = 1uL.. 23) break + } + if (list12 != listOf()) { + return "Wrong elements for 1uL..() + for (i in 1u..<5u) { + list1.add(i) + if (list1.size > 23) break + } + if (list1 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1u..<5u: $list1" + } + + val list2 = ArrayList() + for (i in 1u.toUByte()..<5u.toUByte()) { + list2.add(i) + if (list2.size > 23) break + } + if (list2 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1u.toUByte()..<5u.toUByte(): $list2" + } + + val list3 = ArrayList() + for (i in 1u.toUShort()..<5u.toUShort()) { + list3.add(i) + if (list3.size > 23) break + } + if (list3 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1u.toUShort()..<5u.toUShort(): $list3" + } + + val list4 = ArrayList() + for (i in 1uL..<5uL) { + list4.add(i) + if (list4.size > 23) break + } + if (list4 != listOf(1u, 2u, 3u, 4u)) { + return "Wrong elements for 1uL..<5uL: $list4" + } + + return "OK" +} diff --git a/compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroToMinValue.kt b/compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroToMinValue.kt index d7a846dd431..1d41aaaad3a 100644 --- a/compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroToMinValue.kt +++ b/compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroToMinValue.kt @@ -1,4 +1,5 @@ // Auto-generated by org.jetbrains.kotlin.generators.tests.GenerateRangesCodegenTestData. DO NOT EDIT! +// !LANGUAGE: +RangeUntilOperator // WITH_STDLIB @@ -7,6 +8,7 @@ val MinUB = UByte.MIN_VALUE val MinUS = UShort.MIN_VALUE val MinUL = ULong.MIN_VALUE +@OptIn(ExperimentalStdlibApi::class) fun box(): String { val list1 = ArrayList() for (i in 1u.toUByte()..MinUB step 3) { @@ -80,5 +82,41 @@ fun box(): String { return "Wrong elements for 1uL until MinUL step 3: $list8" } + val list9 = ArrayList() + for (i in 1u.toUByte().. 23) break + } + if (list9 != listOf()) { + return "Wrong elements for 1u.toUByte()..() + for (i in 1u.toUShort().. 23) break + } + if (list10 != listOf()) { + return "Wrong elements for 1u.toUShort()..() + for (i in 1u.. 23) break + } + if (list11 != listOf()) { + return "Wrong elements for 1u..() + for (i in 1uL.. 23) break + } + if (list12 != listOf()) { + return "Wrong elements for 1uL..(1u, 2u, 3u, 4u)) } + @Test fun openRangeUntil() { + doTest(1..<5, 1, 4, 1, listOf(1, 2, 3, 4)) + doTest(1.toByte()..<5.toByte(), 1, 4, 1, listOf(1, 2, 3, 4)) + doTest(1.toShort()..<5.toShort(), 1, 4, 1, listOf(1, 2, 3, 4)) + doTest(1L..<5L, 1L, 4L, 1L, listOf(1, 2, 3, 4)) + doTest('a'..<'d', 'a', 'c', 1, listOf('a', 'b', 'c')) + + doTest(1u..<5u, 1u, 4u, 1, listOf(1u, 2u, 3u, 4u)) + doTest(1u.toUByte()..<5u.toUByte(), 1u, 4u, 1, listOf(1u, 2u, 3u, 4u)) + doTest(1u.toUShort()..<5u.toUShort(), 1u, 4u, 1, listOf(1u, 2u, 3u, 4u)) + doTest(1uL..<5uL, 1uL, 4uL, 1L, listOf(1u, 2u, 3u, 4u)) + } + @Test fun emptyDownto() { doTest(5 downTo 10, 5, 10, -1, listOf()) @@ -475,6 +488,11 @@ public class RangeIterationTest : RangeIterationTestBase() { doTest(0 until MinI step 3, 1, 0, 3, listOf()) doTest(0L until MinL step 3, 1L, 0L, 3L, listOf()) + doTest(0.toByte()..