<sub-class-of type="application/zip"/>
  </mime-type>

  <!-- can't tell from the root element whether this is fodt, fodp, etc.
     This is a made up general mime to cover the open office flat formats.
      Subtype detection can be done with the document:mime attribute in the root
      element and/or file extensions fodt...-->
  <mime-type type="application/vnd.oasis.opendocument.tika.flat.document">

- `LabelSelectors` specified in `topologySpreadConstraints` were validated to ensure that pods are scheduled as expected. Existing pods with invalid `LabelSelectors` could be updated, but new pods were required to specify valid `LabelSelectors`. ([#111802](https://github.com/kubernetes/kubernetes/pull/111802), [@maaoBit](https://github.com/maaoBit))

  Previously, when unschedulable Pods are updated, the scheduler always put Pods back to activeQ/backoffQ. But, actually not all updates to Pods make Pods schedulable, especially considering many scheduling constraints nowadays are immutable.

  }

  public void testLinkedGetAdd() {
    LinkedListMultimap<String, Integer> map = create();
    map.put("bar", 1);
    Collection<Integer> foos = map.get("foo");
    foos.add(2);
    foos.add(3);
    map.put("bar", 4);
    map.put("foo", 5);
    assertEquals("{bar=[1, 4], foo=[2, 3, 5]}", map.toString());

  Similarly you can also access  kubelet's `/pods` endpoint to fetch a list of Pods bound to that node by granting the caller `nodes/pods` permission in RBAC.
  Similarly you can also access kubelet's `/configz` endpoint to fetch kubelet's configuration by granting the caller `nodes/configz` permission in RBAC.

        assertTrue(content.contains("テスト"));
    }

    public void test_getText_ooos() {
        InputStream in = ResourceUtil.getResourceAsStream("extractor/ooo/test.ods");
        Map<String, String> params = new HashMap<String, String>();
        params.put("resourceName", "test.ods");
        ExtractData extractData = jodExtractor.getText(in, params);
        String content = extractData.getContent();
        CloseableUtil.closeQuietly(in);

        } catch (final Exception e) {
            CloseableUtil.closeQuietly(fos); // for deleting file
            FileUtil.deleteInBackground(tempFile); // clean up
            throw new CrawlingAccessException("Could not read a response body: " + responseData.getUrl(), e);
        } finally {
            CloseableUtil.closeQuietly(fos);
        }
        return tempFile;
    }

        String testContent = "Hello, World!";
        tempFile = File.createTempFile("test", ".tmp", Curl.tmpDir);

        // Write test content to file
        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
            fos.write(testContent.getBytes("UTF-8"));
        }

        ContentCache cache = new ContentCache(tempFile);

        try (InputStream stream = cache.getInputStream()) {

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(propertiesFile);
            properties.store(fos, propertiesFile.getName());
        } catch (final IOException e) {
            throw new FileAccessException("ECL0112", new Object[] { propertiesFile.getAbsolutePath() }, e);
        } finally {
            if (fos != null) {
                try {

consequence of this change the Kubelet now correctly takes into account the resources of running and terminating pods when deciding to accept new pods, since terminating pods are still holding on to those resources. This stricter handling may surface to end users as pod rejections when creating pods that are scheduled to mostly full nodes that have other terminating pods holding the resources the new pods need. The most likely error would be a pod set to `Failed` phase with reason set to `OutOfCpu` or `OutOfMemory`,...