python3 -m wheel pack "${pkg_name}"
done

# Switch back to the original working directory. This is needed to ensure that
# cleanup steps at the end of the script works as expected.
popd

echo "Following installer wheels were generated: "
ls "${TFCI_OUTPUT_DIR}"/*.whl

if [[ "$TFCI_ARTIFACT_STAGING_GCS_ENABLE" == 1 ]]; then
  # Note: -n disables overwriting previously created files.

            init.setContextFlag(NegTokenInit.INTEGRITY, true);
            init.setContextFlag(NegTokenInit.CONFIDENTIALITY, true);

            int expected = NegTokenInit.DELEGATION | NegTokenInit.INTEGRITY | NegTokenInit.CONFIDENTIALITY;
            assertEquals(expected, init.getContextFlags());

            // Verify each flag individually
            assertTrue(init.getContextFlag(NegTokenInit.DELEGATION));

	fi

	((attempt++))
done

status=$(./mc admin group info site1 site-replication-issue-group --json | jq .groupStatus | tr -d '"')

if [[ $status == "enabled" ]]; then
	echo "Success"
else
	echo "Expected status: enabled, actual status: $status"
	exit 1
fi

cleanup

## change working directory

                        true -> Optional.of(entry.value)
                        false -> Optional.empty()
                    }
                }.orElse(provider {
                    throw GradleException("Expected boolean flag to be configured")
                })
            }
            .reduce { acc, next ->
                acc.zip(next) { left , right ->
                    when {

        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content
        assertArrayEquals(new byte[] { 0x02, 0x03, 0x04, 0x00, 0x00 }, dest, "Encoded bytes should match the expected subset");
    }

    @Test
    void testEncodeWithOffset() {
        // Test encoding with a destination offset
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };

func (e *Evaluator) Eval(objs []ObjectOpts) ([]Event, error) {
	if len(objs) == 0 {
		return nil, nil
	}
	if len(objs) != objs[0].NumVersions {
		return nil, fmt.Errorf("number of versions mismatch, expected %d, got %d", objs[0].NumVersions, len(objs))
	}
	return e.eval(objs, time.Now().UTC()), nil

            assertNotNull(schemaLocation);
            assertTrue(
                    schemaLocation.contains(targetVersion),
                    "Expected " + schemaLocation + " to contain " + targetVersion);
        }

        @Test
        @DisplayName("should handle unknown model version in schema location")

//
// -- if input is RRS but RRS is not configured/initialized '-1' parity
//
//	for RRS is assumed, the caller is expected to choose the right parity
//	at that point.
//
// -- if input is STANDARD but STANDARD is not configured/initialized '-1' parity
//
//	is returned, the caller is expected to choose the right parity
//	at that point.
func (sCfg *Config) GetParityForSC(sc string) (parity int) {
	ConfigLock.RLock()

        TopDocs topDocs = new IndexSearcher(reader).search(scriptScoreQuery(factory), 10);
        if (topDocs.scoreDocs[0].score != 1_000_000) {
            throw new AssertionError("Expected score to be 1,000,000 but was [" + topDocs.scoreDocs[0].score + "]");
        }
        return topDocs;
    }

    private Query scriptScoreQuery(ScoreScript.Factory factory) {

        withTimeout(1.seconds) {
          call.executeAsync().use {
            withContext(Dispatchers.IO) {
              it.body.string()
            }
            fail("No expected to get response")
          }
        }
      }

      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun cancelledCall() {
    runTest {
      server.enqueue(