}

    @Nested
    @DisplayName("Modification Behavior")
    class ModificationBehaviorTests {

        @Test
        @DisplayName("should save modifications to disk")
        void shouldSaveModificationsToDisk() {
            assertTrue(applyGoal.shouldSaveModifications(), "Apply goal should save modifications to disk");
        }
    }

    @Nested
    @DisplayName("Execution")

        this.loc = loc;
    }

    /**
     * Returns the last modification date of this sitemap entry.
     * @return the last modification date
     */
    @Override
    public String getLastmod() {
        return lastmod;
    }

    /**
     * Sets the last modification date of this sitemap entry.
     * @param lastmod the last modification date to set
     */
    public void setLastmod(final String lastmod) {

            // create
            newInputs = inputs;
            newOutputs = outputs;
        }
    }

    /**
     * Gets the new input words.
     * Returns a defensive copy to prevent external modification.
     *
     * @return The new input words (defensive copy).
     */
    public String[] getNewInputs() {
        return newInputs == null ? null : newInputs.clone();
    }

    /**

        // Test that includes modification preserves targetPath (tests ConnectedResource functionality)
        customResource.addInclude("*.properties");
        assertEquals(
                "custom-output", customResource.getTargetPath(), "targetPath should survive includes modification");
        assertEquals(1, customResource.getIncludes().size(), "Should have one include");

            newOutput = output;
        }
    }

    /**
     * Returns the array of new input character sequences for update operations.
     * Returns a defensive copy to prevent external modification.
     *
     * @return array of new input sequences (defensive copy), or null if no updates are pending
     */
    public String[] getNewInputs() {
        return newInputs == null ? null : newInputs.clone();
    }

labels.search_result_sort_content_length_asc=par taille (asc)
labels.search_result_sort_content_length_desc=par taille (desc)
labels.search_result_sort_last_modified_asc=par dernière modification (asc)
labels.search_result_sort_last_modified_desc=par dernière modification (desc)
labels.search_result_sort_click_count_asc=par nombre de clics (asc)
labels.search_result_sort_click_count_desc=par nombre de clics (desc)

// The slice is valid for use only until the next buffer modification (that is,
// only until the next call to a method like [Buffer.Read], [Buffer.Write], [Buffer.Reset], or [Buffer.Truncate]).
// The slice aliases the buffer content at least until the next buffer modification,
// so immediate changes to the slice will affect the result of future reads.

   * AtomicInteger's atomic operations, with some help from ConcurrentMap's atomic operations on
   * creation and removal (including automatic removal of zeroes). If the modification of an
   * AtomicInteger results in zero, we compareAndSet the value to zero; if that succeeds, we remove
   * the entry from the Map. If another operation sees a zero in the map, it knows that the entry is

  abstract ObjectCountHashMap<E> newBackingMap(int distinctElements);

  @Override
  public final int count(@Nullable Object element) {
    return backingMap.get(element);
  }

  // Optional Operations - Modification Operations

  /**
   * {@inheritDoc}
   *
   * @throws IllegalArgumentException if the call would result in more than {@link
   *     Integer#MAX_VALUE} occurrences of {@code element} in this multiset.
   */

        ResponseData data3 = new ResponseData();
        data3.setUrl("https://example.com");
        data3.setHttpStatusCode(404);

        // All should complete without error and without modification
        processor.process(data1);
        processor.process(data2);
        processor.process(data3);

        // data3 should still have its original values