return !(isLocal(url.getHost()) || url.getProtocol().equals("file"));
        } catch (MalformedURLException e) {
            // bad url just skip it here. It should have been validated already, but the wagon lookup will deal with it
            return false;
        }
    }

    private static boolean isLocal(String host) {
        return "localhost".equals(host) || "127.0.0.1".equals(host);
    }

    /**

// the upstream reader after close has been called.
type disconnectReader struct {
	r  io.Reader
	mu sync.Mutex
}

func (d *disconnectReader) Read(p []byte) (n int, err error) {
	d.mu.Lock()
	defer d.mu.Unlock()
	if d.r != nil {
		return d.r.Read(p)
	}
	return 0, errors.New("reader closed")
}

func (d *disconnectReader) Close() error {
	d.mu.Lock()
	d.r = nil
	d.mu.Unlock()
	return nil

name: VulnCheck
on:
  pull_request:
    branches:
      - master

  push:
    branches:
      - master

permissions:
  contents: read # to fetch code (actions/checkout)

jobs:
  vulncheck:
    name: Analysis
    runs-on: ubuntu-latest
    steps:
      - name: Check out code into the Go module directory
        uses: actions/checkout@v4
      - name: Set up Go
        uses: actions/setup-go@v5
        with:

// The result is unaffected by any method calls except [Reader.Reset].
func (r *Reader) Size() int64 { return int64(len(r.s)) }

// Read implements the [io.Reader] interface.
func (r *Reader) Read(b []byte) (n int, err error) {
	if r.i >= int64(len(r.s)) {
		return 0, io.EOF
	}
	r.prevRune = -1
	n = copy(b, r.s[r.i:])
	r.i += int64(n)
	return
}

        }

        return ComponentUtil.getScriptEngineFactory().getScriptEngine(scriptType).evaluate(template, paramMap);
    }

    /**
     * Get the read interval.
     * @param paramMap The parameters.
     * @return The read interval.
     */
    protected long getReadInterval(final DataStoreParams paramMap) {
        long readInterval = 0;
        final String value = paramMap.getAsString("readInterval");

    }

    @Test
    void testReadParameterWordsWireFormat() {
        byte[] buffer = new byte[1024];
        int result = response.readParameterWordsWireFormat(buffer, 0);

        // The method should read parameter words
        assertTrue(result >= 0, "readParameterWordsWireFormat should return non-negative value");
    }

    @Test
    void testWriteBytesWireFormat() {
        byte[] dst = new byte[1024];

    }
  }

  /**
   * We had a bug where a custom `ResponseBody` interacted poorly with `Response.trailers()`.
   * Confirm custom trailers can be read without even accessing the response body.
   */
  @Test
  fun customTrailersDoNotUseResponseBody() {
    val response =
      Response
        .Builder()

        // When & Then - Will throw SMBProtocolDecodingException when trying to read beyond buffer
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            response.readBytesWireFormat(buffer, offset);
        });
    }

    @DisplayName("Should read at different offsets correctly")
    @ParameterizedTest
    @ValueSource(ints = { 0, 10, 50, 100, 200 })

      CharSequence encoded,
      int start,
      ImmutableMap.Builder<String, PublicSuffixType> builder) {

    int encodedLen = encoded.length();
    int idx = start;
    char c = '\0';

    // Read all the characters for this node.
    for (; idx < encodedLen; idx++) {
      c = encoded.charAt(idx);

      if (c == '&' || c == '?' || c == '!' || c == ':' || c == ',') {
        break;
      }
    }

        assertEquals(TransPeekNamedPipeResponse.STATUS_LISTENING, response.getStatus());
        // Middle bytes were read but not used
    }

    @Test
    @DisplayName("Test consecutive reads update state correctly")
    void testConsecutiveReads() {
        // First read
        byte[] buffer1 = new byte[10];
        SMBUtil.writeInt2(100, buffer1, 0);
        SMBUtil.writeInt2(0, buffer1, 2);