headers['authorization'] = urllib3.make_headers(
                basic_auth='%s:%s' % (self.cid, self.csec))['authorization']

            response = self._http.urlopen('POST', self.idp_ep,
                                          body="grant_type=client_credentials",
                                          headers=headers,
                                          preload_content=True,

            });
            fail("Should have thrown exception");
        } catch (CIFSException e) {
            // Expected - failure in HALF_OPEN should reopen circuit
        }

        assertEquals(State.OPEN, circuitBreaker.getState(), "Circuit should reopen after failure in HALF_OPEN");
    }

    @Test
    public void testStateTransitionMetrics() throws Exception {

            It will be closed if no further activity occurs. Thank you.
          close-issue-message: >
            This issue was closed because it has been inactive for 7 days since being marked as stale.
            Please reopen if you'd like to work on this further.
          days-before-pr-stale: 14
          days-before-pr-close: 14

        verify(tree, atLeastOnce()).release();

        // Re-prepare state for second branch: not open but handle set
        when(fileHandle.isValid()).thenReturn(false);
        // Need to reopen logic to set handle again
        // Reset open flag by reconstructing target
        target = new SmbPipeHandleImpl(pipe);

        target.ensureOpen(); // handle present but invalid per isValid=false

    /**
     * Flag indicating that the file index field contains a valid index.
     */
    public static final byte SMB2_INDEX_SPECIFIED = 0x4;

    /**
     * Flag to reopen the directory enumeration.
     */
    public static final byte SMB2_REOPEN = 0x10;

    private byte fileInformationClass = FILE_BOTH_DIRECTORY_INFO;
    private byte queryFlags;
    private int fileIndex;

        // Open the circuit
        circuitBreaker.tripBreaker();

        // Wait for timeout
        Thread.sleep(150);

        // Single failure in HALF_OPEN should reopen
        try {
            circuitBreaker.call(() -> {
                throw new RuntimeException("Test failure");
            });
        } catch (Exception e) {
            // Expected
        }

        when(mockFileHandle.getFileId()).thenReturn(new byte[16]);
        when(mockFileHandle.acquire()).thenReturn(mockFileHandle);

        // Mock for ensureOpen to reopen file
        when(mockFile.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(mockFileHandle);

        when(mockTreeHandle.send(any(Smb2WriteRequest.class), any())).thenReturn(mockWriteResponse);

                            ioff += maxChunkSize;
                        }

                        if (dfd == null || !dfd.isValid()) {
                            // don't reopen the file for every round if it's not necessary, keep the lock
                            dfd = openCopyTargetFile(dest, src.getAttributes(), !write);
                        }

        }
        file.open(openFlags, access | SmbConstants.FILE_WRITE_DATA, SmbFile.ATTR_NORMAL, 0);
        this.openFlags &= ~(SmbFile.O_CREAT | SmbFile.O_TRUNC); /* in case close and reopen */
        writeSize = file.tree.session.transport.snd_buf_size - 70;

        useNTSmbs = file.tree.session.transport.hasCapability(SmbConstants.CAP_NT_SMBS);
        if (useNTSmbs) {

            this.writeSizeFile = sendBufferSize;
            return;
        }

        this.openFlags &= ~(SmbConstants.O_CREAT | SmbConstants.O_TRUNC); /* in case we close and reopen */
        this.writeSize = sendBufferSize - 70;

        this.useNTSmbs = th.hasCapability(SmbConstants.CAP_NT_SMBS);
        if (!this.useNTSmbs) {
            log.debug("No support for NT SMBs");
        }