/** An implementation of {@link List#equals(Object)}. */
  static boolean equalsImpl(List<?> thisList, @Nullable Object other) {
    if (other == checkNotNull(thisList)) {
      return true;
    }
    if (!(other instanceof List)) {
      return false;
    }
    List<?> otherList = (List<?>) other;
    int size = thisList.size();
    if (size != otherList.size()) {
      return false;
    }

				return err
			}
		}

		header, err := tarReader.Next()
		switch {
		// if no more files are found return
		case err == io.EOF:
			wg.Wait()
			return asyncErr

		// return any other error
		case err != nil:
			wg.Wait()
			extra := ""
			if n > 0 {
				extra = fmt.Sprintf(" after %d successful object(s)", n)
			}
			return fmt.Errorf("tar file error: %w%s", err, extra)

				// to decommission, just skip it, this also includes
				// any other versions that have already expired.
				remainingVersions := len(fivs.Versions) - expired
				if version.Deleted && remainingVersions == 1 && rcfg == nil {
					decommissioned++
					stopFn(version.Size, errors.New("DELETE marked object with no other non-current versions will be skipped"))
					continue
				}

        putAll(entry.getKey(), entry.getValue());
      }
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    Builder<K, V> combine(ImmutableMultimap.Builder<K, V> other) {
      super.combine(other);
      return this;
    }

    /**
     * {@inheritDoc}
     *
     * @since 8.0
     */
    @CanIgnoreReturnValue
    @Override

			},
			expectedPreSignValues: preSignValues{},
			expectedErrCode:       ErrInvalidQueryParams,
		},
		// Test case - 2.
		// Test case with invalid  "X-Amz-Algorithm" query value.
		// The other query params should exist, other wise ErrInvalidQueryParams will be returned because of missing fields.
		{
			inputQueryKeyVals: []string{
				"X-Amz-Algorithm", "InvalidValue",
				"X-Amz-Credential", "",
				"X-Amz-Signature", "",

   */
  fun newBuilder(link: String): Builder? =
    try {
      Builder().parse(this, link)
    } catch (_: IllegalArgumentException) {
      null
    }

  override fun equals(other: Any?): Boolean = other is HttpUrl && other.url == url

  override fun hashCode(): Int = url.hashCode()

  override fun toString(): String = url

  /**

            return null;
        } catch (IllegalAccessException e) {
            // Cannot access field due to security restrictions
            return null;
        } catch (Exception e) {
            // Other errors, return null instead of throwing
            return null;
        }
    }

    void getSmbTree_happy() {
        when(session.getSmbTree(anyString(), anyString())).thenReturn(tree);

        String share = "share";
        String svc = "A:"; // service string example (e.g., DISK, IPC, or other)
        SmbTree result = session.getSmbTree(share, svc);

        assertSame(tree, result);

        ArgumentCaptor<String> shareCap = ArgumentCaptor.forClass(String.class);

            QueryBuilder result = newQueryProcessor.execute(context, query, 1.0f);
            assertNotNull(result);
        } finally {
            // Reset to the original queryProcessor for other tests
            ComponentUtil.register(originalProcessor, "queryProcessor");
        }
    }

            } catch (Exception e) {
                log.warn("Error creating SmbFile from cache for {}: {}", fileInfo.getName(), e.getMessage());
                // For testing purposes, continue processing other files
                // In a real scenario, you might want to handle this differently
            }
        }

        return files;
    }

    /**
     * Update directory cache with new listing