name: "Conflict detector"
on:
  push:
  pull_request_target:
    types: [synchronize]

jobs:
  main:
    permissions:
      contents: read
      pull-requests: write
    runs-on: ubuntu-latest
    steps:
      - name: Check if PRs have merge conflicts
        uses: eps1lon/actions-label-merge-conflict@v3
        with:
          dirtyLabel: "conflicts"
          repoToken: "${{ secrets.GITHUB_TOKEN }}"

            // Test read parameter words
            Method readParams = SmbComNtCancel.class.getDeclaredMethod("readParameterWordsWireFormat", byte[].class, int.class);
            readParams.setAccessible(true);
            assertEquals(0, readParams.invoke(cancel, buffer, position));

            // Test read bytes

For more information, see
https://www.iana.org/time-zones
ftp://ftp.iana.org/tz/code/tz-link.html
https://datatracker.ietf.org/doc/html/rfc6557

# `Request` class

You can declare a parameter in a *path operation function* or dependency to be of type `Request` and then you can access the raw request object directly, without any validation, etc.

Read more about it in the [FastAPI docs about using Request directly](https://fastapi.tiangolo.com/advanced/using-request-directly/)

You can import it directly from `fastapi`:

```python
from fastapi import Request
```

/// tip

type Target struct {
	status int32

	totalMessages  int64
	failedMessages int64

	wg sync.WaitGroup

	// Channel of log entries.
	// Reading logCh must hold read lock on logChMu (to avoid read race)
	// Sending a value on logCh must hold read lock on logChMu (to avoid closing)
	logCh   chan any
	logChMu sync.RWMutex

	// store to persist and replay the logs to the target
	// to avoid missing events when the target is down.

    public void test_indexFromQueryLogReaderWithErrorThrowingReader() throws Exception {
        QueryLogReader errorReader = new QueryLogReader() {
            @Override
            public QueryLog read() {
                throw new RuntimeException("Simulated read error");
            }

            @Override
            public void close() {
            }
        };

        CountDownLatch latch = new CountDownLatch(1);

                                "content": {"application/json": {"schema": {}}},
                            }
                        },
                        "summary": "Read Items",
                        "operationId": "read_items_items__get",
                        "security": [{"OAuth2PasswordBearer": []}],
                    }
                }
            },
            "components": {

        // 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 })

			s.buf = newBuf
			s.end -= s.start
			s.start = 0
		}
		// Finally we can read some input. Make sure we don't get stuck with
		// a misbehaving Reader. Officially we don't need to do this, but let's
		// be extra careful: Scanner is for safe, simple jobs.
		for loop := 0; ; {
			n, err := s.r.Read(s.buf[s.end:len(s.buf)])
			if n < 0 || len(s.buf)-s.end < n {
				s.setErr(ErrBadReadCount)
				break

### Certificate Directory

TLS certificates by default are expected to be stored under ``${HOME}/.minio/certs`` directory. You need to place certificates here to enable `HTTPS` based access. Read more about [How to secure access to MinIO server with TLS](https://docs.min.io/community/minio-object-store/operations/network-encryption.html).

Following is a sample directory structure for MinIO server with TLS certificates.