pathType: Prefix
            backend:
              service:
                name: {{ $fullName }}
                port: 
                  number: {{ $servicePort }}
            {{- else }}
            backend:
              serviceName: {{ $fullName }}
              servicePort: {{ $servicePort }}
            {{- end }}
      {{- if . }}
      host: {{ tpl . $ | quote }}
      {{- end }}

            pathType: Prefix
            backend:
              service:
                name: {{ $fullName }}
                port: 
                  number: {{ $servicePort }}
            {{- else }}
            backend:
              serviceName: {{ $fullName }}
              servicePort: {{ $servicePort }}
            {{- end }}
      {{- if . }}
      host: {{ tpl . $ | quote }}
      {{- end }}

        // has already been moved.
        parent = elementData(removeIndex);
      } else {
        parent = elementData(getParentIndex(removeIndex));
      }
      // bubble it up the opposite heap
      if (otherHeap.bubbleUpAlternatingLevels(crossOver, toTrickle) < removeIndex) {
        return new MoveDesc<>(toTrickle, parent);
      } else {
        return null;
      }
    }

  fun trimToSizeWithActiveEdit(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    val expectedByteCount = if (windows) 10L else 0L
    val afterRemoveFileContents = if (windows) "a1234" else null

    set("a", "a1234", "a1234")
    val a = cache.edit("a")!!
    a.setString(0, "a123")
    cache.maxSize = 8 // Smaller than the sum of active edits!

      @SuppressWarnings("unchecked")
      List<T> result = (List<T>) reversed;
      return result;
    } else if (list instanceof ReverseList) {
      return ((ReverseList<T>) list).getForwardList();
    } else if (list instanceof RandomAccess) {
      return new RandomAccessReverseList<>(list);
    } else {
      return new ReverseList<>(list);
    }
  }

                    // special case: if there is a windows drive letter, then keep the original return value
                    retValue = retValue.charAt(0) + ":" + retValue.substring(2);
                } else {
                    // Now we expect the host
                    int index = retValue.indexOf('/');
                    if (index >= 0) {
                        retValue = retValue.substring(index + 1);

    private static String[] determinePsCommand() {
        if (isWindows()) {
            return new String[]{"wmic", "process", "get", "processid,commandline"};
        } else if (isMacOS()) {
            return new String[]{"ps", "x", "-o", "pid,command"};
        } else {
            return new String[]{"ps", "x", "-o", "pid,cmd"};
        }
    }

    private static boolean isWindows() {

      AbstractTester<?> tester = (AbstractTester<?>) test;
      return getMethod(tester.getClass(), tester.getTestMethodName());
    } else if (test instanceof TestCase) {
      TestCase testCase = (TestCase) test;
      return getMethod(testCase.getClass(), testCase.getName());
    } else {
      throw new IllegalArgumentException("unable to extract method from test: not a TestCase.");
    }
  }

                inSectionElements.remove();

                if (next == null) {
                    break;
                } else {
                    inSection.clear();
                    inSection.add(next);
                    heading = next;
                }
            } else {
                inSection.add(next);
            }
            next = next.nextElementSibling();
        }
    }

                    version = null;
                    goal = p[2];
                } else if (p.length == 4) {
                    // <groupId>:<artifactId>:<version>:<goal>
                    groupId = p[0];
                    artifactId = p[1];
                    version = p[2];
                    goal = p[3];
                } else {
                    // invalid
                    LOGGER.warn(