entry.invalidate();
            break;

        case FILE_REMOVED:
            entry.removeChild(childName);
            break;

        case FILE_MODIFIED:
            // Remove from cache to force refresh
            entry.removeChild(childName);
            break;

        case DIRECTORY_RENAMED:
            // Full invalidation needed

                    break;
                case ResolutionListener.PROCESS_CHILDREN:
                    listener.startProcessChildren(node.getArtifact());
                    break;
                case ResolutionListener.FINISH_PROCESSING_CHILDREN:
                    listener.endProcessChildren(node.getArtifact());
                    break;
                case ResolutionListener.INCLUDE_ARTIFACT:

			throughputHighestPut = totalPut

			if doBreak {
				sendResult()
				break
			}

			for _, result := range results {
				if result.Error != "" {
					// Break out on errors.
					sendResult()
					return
				}
			}

			sendResult()
			if !opts.autotune {
				break
			}

			// Try with a higher concurrency to see if we get better throughput

              multiset.add(key, delta);
              deltas[keyIndex] += delta;
              break;
            }
          case SET_COUNT:
            {
              int newValue = random.nextInt(3);
              int oldValue = multiset.setCount(key, newValue);
              deltas[keyIndex] += newValue - oldValue;
              break;
            }
          case SET_COUNT_IF:
            {

          return;
        }
        break;
      case LAST_PRESENT:
        if (list.contains(key)) {
          assertEquals(list.lastIndexOf(key), answer);
          return;
        }
        break;
      case ANY_PRESENT:
        if (list.contains(key)) {
          assertEquals(key, list.get(answer));
          return;
        }
        break;
      case FIRST_AFTER:
        if (list.contains(key)) {

          val byte1 = this[mid + publicSuffixByteIndex] and 0xff

          compareResult = byte0 - byte1
          if (compareResult != 0) break

          publicSuffixByteIndex++
          currentLabelByteIndex++
          if (publicSuffixByteIndex == publicSuffixLength) break

          if (labels[currentLabelIndex].size == currentLabelByteIndex) {

import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Lease Break Acknowledgment
 *
 * MS-SMB2 2.2.24
 */
public class Smb2LeaseBreakAcknowledgment extends ServerMessageBlock2Request<Smb2LeaseBreakResponse> {

    private static final int STRUCTURE_SIZE = 36;

    private int flags;
    private Smb2LeaseKey leaseKey;
    private int leaseState;

    /**
     * Create a lease break acknowledgment
     *

                        result = false;
                        break;
                    }
                }
                // check for exact match
                else if (repo.equals(originalId)) {
                    result = true;
                    break;
                }
                // check for external:*

                        }
                        break;
                    case ",":
                        if (tokStarted) {
                            retVal = tokBuf.toString();
                            tokStarted = false;
                            tokBuf = new StringBuilder(10);
                            exit = true;
                        }
                        break;
                    case "?":

                    authMethod = "NTLM";
                    break;
                }
                if (currentAuthMethod.indexOf(' ') != 4) {
                    continue;
                }
                authMethod = "NTLM";
                authorization = currentAuthMethod.substring(5).trim();
                break;
            }
            if (currentAuthMethod.startsWith("Negotiate")) {