if (us == 0) {
            this.treeConnection.release();
        } else if (us < 0) {
            throw new RuntimeCIFSException("Usage count dropped below zero");
        }
    }

    @Override
    protected void finalize() throws Throwable {
        try {
            // Add null check to prevent NPE if object was not fully constructed

                }
                if (matcher.group(4) != null) {
                    tag.setId(matcher.group(4).substring(1));
                }
                return tag;
            }
            throw new FessSystemException("Invalid pruned tag: " + v);
        }).toArray(n -> new PrunedTag[n]));
    }

      for (RoundingMode mode : modes) {
        Double previous = expectedValues.put(mode, expectedValue);
        if (previous != null) {
          throw new AssertionError();
        }
      }
      return this;
    }

    @CanIgnoreReturnValue
    RoundToDoubleTester roundUnnecessaryShouldThrow() {
      unnecessaryShouldThrow = true;
      return this;

    void testReadDataWireFormat_BufferTooSmall() throws Exception {
        // Test with buffer too small for complete data
        response = new Trans2QueryFSInformationResponse(config, FileSystemInformation.SMB_INFO_ALLOCATION);

        byte[] buffer = new byte[10]; // Too small for SmbInfoAllocation

        // Set dataCount
        setDataCount(response, 10);

        // This should throw an exception during decode

            fail("Should throw NullPointerException for null input");
        } catch (NullPointerException e) {
            // Expected behavior
        }
    }

    public void test_parse_null_input() {
        // Test null input handling
        try {
            KuromojiCSVUtil.parse(null);
            fail("Should throw NullPointerException for null input");

    if (collection == null) {
      collection = createCollection(key);
      if (collection.add(value)) {
        totalSize++;
        map.put(key, collection);
        return true;
      } else {
        throw new AssertionError("New Collection violated the Collection spec");
      }
    } else if (collection.add(value)) {
      totalSize++;
      return true;
    } else {
      return false;
    }
  }

                                writer.write(hit.getSourceAsString());
                                writer.write("\n");
                            } catch (final IOException e) {
                                throw new IORuntimeException(e);
                            }
                            return true;
                        });
                        writer.flush();
                    }
                });

  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  public void testAddAllAtIndex_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(n, nothing) should return false or throw",
          getList().addAll(0, emptyCollection()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)

    List<Object> invalidated = new ArrayList<>();
    Cache<Integer, Integer> cache =
        new AbstractCache<Integer, Integer>() {
          @Override
          public Integer getIfPresent(Object key) {
            throw new UnsupportedOperationException();
          }

          @Override
          public void invalidate(Object key) {
            invalidated.add(key);
          }
        };

    if (map.containsKey(key)) {
      // When a collision happens, the colliding entry is the first entry
      // of the tail map.
      Entry<K, V> previousEntry = map.tailMap(key).entrySet().iterator().next();
      throw new IllegalArgumentException(
          "Duplicate keys in mappings "
              + previousEntry.getKey()
              + "="
              + previousEntry.getValue()
              + " and "
              + key