*/
@Deprecated
public class RegexBasedModelInterpolator extends AbstractStringBasedModelInterpolator {

    public RegexBasedModelInterpolator() throws IOException {}

    public RegexBasedModelInterpolator(PathTranslator pathTranslator) {
        super(pathTranslator);
    }

    public RegexBasedModelInterpolator(Properties envars) {}

    @Override

        }
        return false;
    }

    @Override
    public E next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return iterators[index].next();
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

  }

  private void assertSetCountNegativeOldCount() {
    try {
      getMultiset().setCount(e3(), -1, 1);
      fail("calling setCount() with a negative oldCount should throw IllegalArgumentException");
    } catch (IllegalArgumentException expected) {
    }
  }

  // Negative oldCount.

  @CollectionFeature.Require(SUPPORTS_ADD)

                    }
                }
                if (field == null) {
                    throw new NoSuchFieldException(fieldName);
                }
                field.setAccessible(true);
                field.set(this, value);
            } catch (Exception e) {
                throw new RuntimeException("Failed to set field " + fieldName, e);
            }
        }

       * learn that some other exception besides IllegalArgumentException is common, then we could
       * add another special case to throw an instance of it, too.
       */
      throw e;
    }
  }

  private static ImmutableList<Method> getAnnotatedMethodsNotCached(Class<?> clazz) {
    Set<? extends Class<?>> supertypes = TypeToken.of(clazz).getTypes().rawTypes();

                pkill(pid);
            });
        }
    }

    private static void initExecutionMode(String[] args) {
        if (args.length != 1) {
            throw new IllegalArgumentException("Requires 1 param: " + Stream.of(ExecutionMode.values()).map(ExecutionMode::toString).collect(Collectors.joining("/")));
        }
        executionMode = ExecutionMode.valueOf(args[0]);

    // required. These socket factories explicitly set the buffer sizes on sockets created.
    server = MockWebServer()
    server.serverSocketFactory =
      object : DelegatingServerSocketFactory(getDefault()) {
        @Throws(SocketException::class)
        override fun configureServerSocket(serverSocket: ServerSocket): ServerSocket {
          serverSocket.setReceiveBufferSize(SOCKET_BUFFER_SIZE)
          return serverSocket
        }
      }

      return EnumMultiset.create(elements);
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testEquals() throws Exception {
    new ClassSanityTester()
        .setDistinctValues(Class.class, Color.class, Gender.class)
        .setDistinctValues(Enum.class, Color.BLUE, Color.RED)

                } catch (final GeneralSecurityException e) {
                    throw new RuntimeCIFSException("Failed to encrypt password", e);
                }
                this.passwordLength = this.password.length;
            } else if (this.ctx.getConfig().isDisablePlainTextPasswords()) {
                throw new RuntimeCIFSException("Plain text passwords are disabled");
            } else {

        throw new UnsupportedOperationException(msg);
    }

    @Override
    protected <RESULT extends Entity> ListResultBean<RESULT> createListResultBean(final ConditionBean cb, final List<RESULT> selectedList) {
        if (selectedList instanceof EsPagingResultBean) {
            return (ListResultBean<RESULT>) selectedList;
        }