// fall through
      case DOWN:
        increment = false;
        break;
      case UP:
        increment = true;
        break;
      case CEILING:
        increment = signum > 0;
        break;
      case FLOOR:
        increment = signum < 0;
        break;
      case HALF_EVEN:
      case HALF_DOWN:
      case HALF_UP:
        int absRem = abs(rem);

                model = profileInjector.injectProfiles(model, activeExternalProfiles, request, problems);
            }

            lineage.add(model);

            if (currentData == superData) {
                break;
            }

            // add repositories specified by the current model so that we can resolve the parent
            if (!model.getRepositories().isEmpty()) {

          continue;
        }
        if (q == j + 1) {
          if (j == 0) {
            break;
          }
          s++;
          switchDirection();
          continue;
        }

        Collections.swap(list, j - c[j] + s, j - q + s);
        c[j] = q;
        break;
      }
    }

    void switchDirection() {
      o[j] = -o[j];
      j--;
    }
  }

          return;
        }
        break;
      case LAST_PRESENT:
        if (list.contains(key)) {
          assertEquals(list.lastIndexOf(key), answer);
          return;
        }
        break;
      case ANY_PRESENT:
        if (list.contains(key)) {
          assertEquals(key, list.get(answer));
          return;
        }
        break;
      case FIRST_AFTER:
        if (list.contains(key)) {

    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {
        assertEquals("entry.setValue() should return the old value", v0(), entry.setValue(v3()));
        break;
      }
    }
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)

                case "clean":
                    packaged = false;
                    break;
                case "package":
                case "install":
                case "deploy":
                    packaged = true;
                    break;
                default:
                    break;
            }
        }
        return packaged;
    }

        if (!external) {
            disableExternalResources(schemaFactory);
        }
        return schemaFactory;
    }

    /**
     * RELAX NGのための{@link SchemaFactory}を生成します。
     *
     * @return RELAX NGのための{@link SchemaFactory}
     */
    public static SchemaFactory newRelaxNgSchemaFactory() {
        return newRelaxNgSchemaFactory(false);
    }

                log.debug(message, throwable);
                break;
            case INFO:
                log.info(message, throwable);
                break;
            case WARN:
                log.warn(message, throwable);
                break;
            case ERROR:
                log.error(message, throwable);
                break;
            case FATAL:
                log.fatal(message, throwable);

                break;
            case 4:
                s = new DefaultArtifact(parts[0], parts[1], "*", parts[2], parts[3]);
                break;
            case 5:
                s = new DefaultArtifact(parts[0], parts[1], parts[2], parts[3], parts[4]);
                break;
            default:

    // separate below
    try {
      range.intersection(Range.closed(0, 2));
      fail();
    } catch (IllegalArgumentException expected) {
      assertThat(expected).hasMessageThat().contains("connected");
    }

    // adjacent below
    assertEquals(Range.closedOpen(4, 4), range.intersection(Range.closedOpen(2, 4)));

    // overlap below