assertSame(EXCEPTION, record.getThrown());
  }

  public void testConcurrentModification() throws Exception {
    // Tests for the absence of a bug where logging while iterating over the
    // stored log records causes a ConcurrentModificationException
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();
    ExampleClassUnderTest.foo();

        }
        // ensure file is open
        file.open( openFlags, access, SmbFile.ATTR_NORMAL, 0 );

        /*
         * Read AndX Request / Response
         */

        if( file.log.level >= 4 )
            file.log.println( "read: fid=" + file.fid + ",off=" + off + ",len=" + len );

        SmbComReadAndXResponse response = new SmbComReadAndXResponse( b, off );

        if( file.type == SmbFile.TYPE_NAMED_PIPE ) {

For example, you could identify a "car" or a "blog post".

Then you could add permissions about that entity, like "drive" (for the car) or "edit" (for the blog).

And then, you could give that JWT token to a user (or bot), and they could use it to perform those actions (drive the car, or edit the blog post) without even needing to have an account, just with the JWT token your API generated for that.

import jcifs.internal.util.SMBUtil;


/**
 * 
 *
 */
public class SmbComClose extends ServerMessageBlock implements Request<SmbComBlankResponse> {

    private static final Logger log = LoggerFactory.getLogger(SmbComClose.class);

    private int fid;
    private long lastWriteTime;


    /**
     * 
     * @param config
     * @param fid
     * @param lastWriteTime
     */

			b.Fatal(err)
		}
	}
}

func TestEncodeDecodeBaseOptions(t *testing.T) {
	v := BaseOptions{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBaseOptions Msgsize() is inaccurate")
	}

	vn := BaseOptions{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)

	sleep.UntilContext(ctx, min(res.Delay(), time.Second))
	// Increment our hits. If we are spamming this loop, we will hit this many times as we continually are sending >1 RPS
	i.hits++
	// Log every 5 times to not spam too much (and not log on initial startup where some reconciling is expected
	if i.hits > 5 {
		detectedCNI := ""
		if strings.Contains(i.in.cniConfigFilepath, "cilium") {
			detectedCNI = "cilium"
		}
		hint := ""

pkg io, var ErrNoProgress error
pkg log, const Ldate = 1
pkg log, const Llongfile = 8
pkg log, const Lmicroseconds = 4
pkg log, const Lshortfile = 16
pkg log, const LstdFlags = 3
pkg log, const Ltime = 2
pkg log/syslog (darwin-386), const LOG_ALERT = 1
pkg log/syslog (darwin-386), const LOG_AUTH = 32
pkg log/syslog (darwin-386), const LOG_AUTH Priority
pkg log/syslog (darwin-386), const LOG_AUTHPRIV = 80

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.log;

import java.util.logging.Level;

/**
 * java.util.logのロガーを利用するアダプタです。
 *
 * @author koichik
 */
class JulLoggerAdapter implements LoggerAdapter {

    protected final String sourceClass;

import jcifs.smb.NtlmPasswordAuthenticator.AuthenticationType;


/**
 * @author mbechler
 *
 */
public abstract class AbstractCIFSContext extends Thread implements CIFSContext {

    private static final Logger log = LoggerFactory.getLogger(AbstractCIFSContext.class);
    private boolean closed;


    /**
     * 
     */
    public AbstractCIFSContext () {
        Runtime.getRuntime().addShutdownHook(this);
    }

		if err != nil {
			b.Fatal(err)
		}
	}
}

func TestEncodeDecodeRStat(t *testing.T) {
	v := RStat{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)

	m := v.Msgsize()
	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeRStat Msgsize() is inaccurate")
	}

	vn := RStat{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)