return set.tailSet(firstExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.EXCLUSIVE) {
        return set.subSet(firstExclusive, false, lastExclusive, false);
      } else if (from == Bound.EXCLUSIVE && to == Bound.INCLUSIVE) {
        return set.subSet(firstExclusive, false, lastInclusive, true);
      } else if (from == Bound.INCLUSIVE && to == Bound.INCLUSIVE) {

     * Determines if the given value is a valid cron expression.
     * @param value the value to validate
     * @return true if valid, false otherwise
     */
    protected boolean determineValid(final String value) {
        if (StringUtil.isNotBlank(value) && !LaCronUtil.isCronExpValid(value)) {
            return false;
        }
        return true;
    }

import org.jspecify.annotations.NullMarked;

@GwtCompatible
@NullMarked
public class TablesTransformValuesColumnMapTest extends ColumnMapTests {
  public TablesTransformValuesColumnMapTest() {
    super(false, true, true, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, String> original = HashBasedTable.create();
    return transformValues(original, FIRST_CHARACTER);
  }

import java.util.Map;
import org.jspecify.annotations.NullMarked;

@GwtCompatible
@NullMarked
public class TablesTransformValuesRowTest extends RowTests {
  public TablesTransformValuesRowTest() {
    super(false, false, true, true, true);
  }

  @Override
  Table<Character, String, Integer> makeTable() {
    Table<Character, String, Integer> table = HashBasedTable.create();

    this(capacity, false);
  }

  /**
   * Creates an {@code MonitorBasedArrayBlockingQueue} with the given (fixed) capacity and the
   * specified access policy.
   *
   * @param capacity the capacity of this queue
   * @param fair if {@code true} then queue accesses for threads blocked on insertion or removal,
   *     are processed in FIFO order; if {@code false} the access order is unspecified.

        void testSetResolveInDfs() {
            testBlock.setResolveInDfs(true);
            assertTrue((testBlock.getFlags2() & SmbConstants.FLAGS2_RESOLVE_PATHS_IN_DFS) != 0);

            testBlock.setResolveInDfs(false);
            assertTrue((testBlock.getFlags2() & SmbConstants.FLAGS2_RESOLVE_PATHS_IN_DFS) == 0);
        }

        @Test
        @DisplayName("Test is resolve in DFS")
        void testIsResolveInDfs() {

                        this.exclusiveTransport = null;
                        this.tree = null;
                        this.treeAcquired = false;
                        et.close();
                        et.disconnect(false, false);
                    } catch (final Exception e) {
                        log.error("Failed to close exclusive transport", e);
                    }
                }

            for (int i = 0; i < this.b.length; i++) {
                if (this.b[i] != t.b[i]) {
                    return false;
                }
            }
            return true;
        } catch (final Throwable e) {
            return false;
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#hashCode()
     */
    @Override

	}, {
		in: []sparseEntry{{1, 0}}, size: 0,
		wantValid: false,
	}, {
		in: []sparseEntry{{-1, 0}}, size: 100,
		wantValid: false,
	}, {
		in: []sparseEntry{{0, -1}}, size: 100,
		wantValid: false,
	}, {
		in: []sparseEntry{{0, 0}}, size: -100,
		wantValid: false,
	}, {
		in: []sparseEntry{{math.MaxInt64, 3}, {6, -5}}, size: 35,
		wantValid: false,
	}, {
		in: []sparseEntry{{1, 3}, {6, -5}}, size: 35,

          <defaultValue>false</defaultValue>
        </field>
        <field>
          <name>offline</name>
          <version>1.0.0+</version>
          <required>false</required>
          <description>
            Indicate whether maven should operate in offline mode full-time.
          </description>
          <type>boolean</type>
          <defaultValue>false</defaultValue>
        </field>