text:
r"""
This code was generated by
\ / _    _  _|   _  _
 | (_)\/(_)(_|\/| |(/_  v1.0.0
      /       /
"""

from tests import IntegrationTestCase
from tests.holodeck import Request
from twilio.base.exceptions import TwilioException
from twilio.http.response import Response

class WorkersRealTimeStatisticsTestCase(IntegrationTestCase):

    def test_fetch_request(self):
        self.holodeck.mock(Response(500, ''))

        with self.assertRaises(TwilioException):
            self.client.taskrouter.v1.workspaces(sid="WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                     .workers(sid="WKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                     .real_time_statistics().fetch()

        self.holodeck.assert_has_request(Request(
            'get',
            'https://taskrouter.twilio.com/v1/Workspaces/WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Workers/RealTimeStatistics',
        ))

    def test_fetch_response(self):
        self.holodeck.mock(Response(
            200,
            '''
            {
                "account_sid": "ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                "workspace_sid": "WSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                "url": "https://taskrouter.twilio.com/v1/Workspaces/WSaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Workers/RealTimeStatistics",
                "total_workers": 15,
                "activity_statistics": [
                    {
                        "friendly_name": "Idle",
                        "workers": 0,
                        "sid": "WAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                    },
                    {
                        "friendly_name": "Busy",
                        "workers": 9,
                        "sid": "WAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                    },
                    {
                        "friendly_name": "Offline",
                        "workers": 6,
                        "sid": "WAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                    },
                    {
                        "friendly_name": "Reserved",
                        "workers": 0,
                        "sid": "WAaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                    }
                ]
            }
            '''
        ))

        actual = self.client.taskrouter.v1.workspaces(sid="WSXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                          .workers(sid="WKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX") \
                                          .real_time_statistics().fetch()

        self.assertIsNotNone(actual)


text:
require 'spec_helper'

describe Optimizer::Function::Predicate::Enumerable::UnoptimizedOperands, '#optimizable?' do
  subject { object.optimizable? }

  let(:attribute) { Attribute::Integer.new(:id)    }
  let(:predicate) { attribute.include(operand)     }
  let(:object)    { described_class.new(predicate) }

  before do
    expect(predicate).to be_kind_of(Function::Predicate::Enumerable)
  end

  context 'when the operand contains an unsorted Enumerable' do
    let(:operand) { [2, 1] }

    it { should be(true) }
  end

  context 'when the operand contains an exclusive Range' do
    let(:operand) { 1...3 }

    it { should be(true) }
  end

  context 'when the operand contains an Enumerable after filtering invalid entries' do
    let(:operand) { ['a', 1, 2] }

    it { should be(true) }
  end

  context 'when the operand contains an Enumerable after filtering duplicate entries' do
    let(:operand) { [1, 1, 2, 2] }

    it { should be(true) }
  end

  context 'when the operand contains a sorted Enumerable' do
    let(:operand) { [1, 2] }

    it { should be(false) }
  end

  context 'when the operand contains an inclusive Range' do
    let(:operand) { 1..2 }

    it { should be(false) }
  end
end

redpajama_set_name: RedPajamaGithub


text:
\chapter{Data Preparation}

\section{Audible Event List}

\section{Audio Data}


text:
import { app } from 'hyperapp';
import { cloneDeep } from 'lodash';
import actions from './actions';
import state from './state';
import view from './view';

import { hyperlog } from './utils/logger';
import core from './core';

const defaultState = cloneDeep(state);
delete defaultState.default;
state.default = defaultState;

const wiredActions = hyperlog(app)(state, actions, view, document.body);

document.onreadystatechange = () => {
    if (document.readyState === 'complete') {
        wiredActions.restoreState();
        wiredActions.setSplashScreenState(false);
        console.log(wiredActions);
    }
};

core(wiredActions);

// This disables bouncing in iOS
// https://bugs.webkit.org/show_bug.cgi?id=182521
// https://stackoverflow.com/a/50856621/1589989
// this is commented out since its prevents from moving thumb on mobile devices
// window.addEventListener("touchmove", (event) => event.preventDefault(), {passive: false} );

window.oncontextmenu = (event) => {
    event.preventDefault();
    event.stopPropagation();
    return false;
};


text:
using System;

namespace ThinkingHome.Plugins.Cron
{
    [AttributeUsage(AttributeTargets.Method)]
    public class CronHandlerAttribute : Attribute
    {
    }
}


text:
package uk.ac.bham.cs.bhamnav.futurework;

import java.io.Serializable;

import android.text.format.Time;

public class Event implements Serializable{

	/**
	 *
	 */
	private static final long serialVersionUID = 6271364378718527172L; // generated ID for the Serializable
	String name;
	String room;
	String building;
	Time startTime;
	int duration;

	int hour;
	int minutes;
	int dayofmonth;
	int month;
	int year;

	/*
	 * Time class is not Serializable, so will have to do with
	 * alternate means
	 */

	public Event(String lecturename, int h, int min, int dayofM, int mont, int yr, int durationinminutes, String lectureroom, String lecturebuilding){

		// do some data verification/validation
		name = lecturename;
		hour = h;
		minutes = min;
		dayofmonth = dayofM;
		month = mont;
		year = yr;
		duration = durationinminutes;
		room = lectureroom;
		building = lecturebuilding;
	}

}


text:
//  TEST    Foundation::Containers::Queue
//      STATUS  PRELIMINARY
#include "Stroika/Foundation/StroikaPreComp.h"

#include <iostream>
#include <sstream>

#include "Stroika/Foundation/Containers/Concrete/Queue_Array.h"
#include "Stroika/Foundation/Containers/Concrete/Queue_DoublyLinkedList.h"
#include "Stroika/Foundation/Containers/Queue.h"
#include "Stroika/Foundation/Debug/Assertions.h"
#include "Stroika/Foundation/Debug/Trace.h"

#include "../TestCommon/CommonTests_Queue.h"
#include "../TestHarness/SimpleClass.h"
#include "../TestHarness/TestHarness.h"

using namespace Stroika;
using namespace Stroika::Foundation;
using namespace Stroika::Foundation::Containers;

using Concrete::Queue_Array;
using Concrete::Queue_DoublyLinkedList;

namespace {
    template <typename CONCRETE_CONTAINER, typename EQUALS_COMPARER>
    void SimpleQueueTest_All_NotRequiringEquals_For_Type ()
    {
        CommonTests::QueueTests::SimpleQueueTest_All_NotRequiringEquals_For_Type<CONCRETE_CONTAINER, EQUALS_COMPARER> ();
    }

    template <typename CONCRETE_CONTAINER, typename EQUALS_COMPARER>
    void SimpleQueueTest_All_For_Type ()
    {
        CommonTests::QueueTests::SimpleQueueTest_All_For_Type<CONCRETE_CONTAINER, EQUALS_COMPARER> ();
    }
}

namespace {
    void DoRegressionTests_ ()
    {
        using COMPARE_SIZET       = std::equal_to<size_t>;
        using COMPARE_SimpleClass = std::equal_to<SimpleClass>;
        struct COMPARE_SimpleClassWithoutComparisonOperators {
            using value_type = SimpleClassWithoutComparisonOperators;
            bool operator() (value_type v1, value_type v2) const
            {
                return v1.GetValue () == v2.GetValue ();
            }
        };

        SimpleQueueTest_All_For_Type<Queue<size_t>, COMPARE_SIZET> ();
        SimpleQueueTest_All_For_Type<Queue<SimpleClass>, COMPARE_SimpleClass> ();
        SimpleQueueTest_All_NotRequiringEquals_For_Type<Queue<SimpleClassWithoutComparisonOperators>, COMPARE_SimpleClassWithoutComparisonOperators> ();
        SimpleQueueTest_All_For_Type<Queue<SimpleClassWithoutComparisonOperators>, COMPARE_SimpleClassWithoutComparisonOperators> ();

        SimpleQueueTest_All_For_Type<Queue_Array<size_t>, COMPARE_SIZET> ();
        SimpleQueueTest_All_For_Type<Queue_Array<SimpleClass>, COMPARE_SimpleClass> ();
        SimpleQueueTest_All_NotRequiringEquals_For_Type<Queue_Array<SimpleClassWithoutComparisonOperators>, COMPARE_SimpleClassWithoutComparisonOperators> ();
        SimpleQueueTest_All_For_Type<Queue_Array<SimpleClassWithoutComparisonOperators>, COMPARE_SimpleClassWithoutComparisonOperators> ();

        SimpleQueueTest_All_For_Type<Queue_DoublyLinkedList<size_t>, COMPARE_SIZET> ();
        SimpleQueueTest_All_For_Type<Queue_DoublyLinkedList<SimpleClass>, COMPARE_SimpleClass> ();
        SimpleQueueTest_All_NotRequiringEquals_For_Type<Queue_DoublyLinkedList<SimpleClassWithoutComparisonOperators>, COMPARE_SimpleClassWithoutComparisonOperators> ();
        SimpleQueueTest_All_For_Type<Queue_DoublyLinkedList<SimpleClassWithoutComparisonOperators>, COMPARE_SimpleClassWithoutComparisonOperators> ();

        VerifyTestResult (SimpleClass::GetTotalLiveCount () == 0 and SimpleClassWithoutComparisonOperators::GetTotalLiveCount () == 0); // simple portable leak check
    }
}

int main ([[maybe_unused]] int argc, [[maybe_unused]] const char* argv[])
{
    Stroika::TestHarness::Setup ();
    return Stroika::TestHarness::PrintPassOrFail (DoRegressionTests_);
}


text:
namespace CivGen
{
    using System;
    using System.Collections.Generic;

    public partial class Feature_AdjacentYields
    {
        public string FeatureType { get; set; }
        public string YieldType { get; set; }
        public long YieldChange { get; set; }

        public virtual Yield Yield { get; set; }
        public virtual Feature Feature { get; set; }
    }
}


text:
	<?php foreach ($news_detail as $rowNews): ?>
		<input type="hidden" name="id_news" value="<?php echo $rowNews['id_news'];?>" >

			Title/หัวข้อ

				<input type="text" name='title' class="form-control " id="title" placeholder="เพิ่มหัวข้อที่เกี่ยวข้องกับข่าว" autofocus="" required  oninvalid="this.setCustomValidity('กรุณากรอกข้อมูล ')" oninput="setCustomValidity('')" value="<?php echo $rowNews['news_title']; ?>">

			รายละเอียด

				<textarea name="detail" class="form-control" rows="15"><?php echo  str_replace(array("
"," "),array('', " "),$rowNews['news_detail']); ?></textarea>

	<?php endforeach ?>


text:
package net.modelbased.proasense.adapter.webservice;

public class WebServiceConsumerInput {
}


text:
#region License

#endregion License

using System;

namespace JsonFx.Serialization.Resolvers
{
	public interface IResolverCacheContainer
	{
		ResolverCache ResolverCache { get; }
	}
}


text:
<?php

/**
 * Throw an error, a callstack and then exit
 *
 * @phpstub
 *
 * @param string $warning
 * @param string $delimiter
 *
 * @return void
 */
function apd_croak($warning, $delimiter = NULL)
{
}


text:
package cz.nudz.www.trainingapp.dialogs;

import android.content.Context;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v7.app.AlertDialog;

import cz.nudz.www.trainingapp.R;

/**
 * Created by artem on 21-Sep-17.
 */

public class YesNoDialogFragment extends AlertDialogFragment {

    public static final String TAG = YesNoDialogFragment.class.getSimpleName();
    private YesNoDialogFragmentListener listener;

    public static YesNoDialogFragment newInstance(@Nullable String title, @NonNull String message) {
        Bundle args = AlertDialogFragment.bundleArguments(title, message);
        YesNoDialogFragment yesNoDialogFragment = new YesNoDialogFragment();
        yesNoDialogFragment.setArguments(args);
        return yesNoDialogFragment;
    }

    @Override
    protected void init(AlertDialog.Builder builder) {
        super.init(builder);
        builder.setNegativeButton(R.string.no, (dialog, which) -> {
            dialog.dismiss();
            YesNoDialogFragment.this.dismiss();
        });
        builder.setPositiveButton(R.string.yes, (dialog, which) -> listener.onYes());
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof YesNoDialogFragmentListener) {
            listener = (YesNoDialogFragmentListener) context;
        } else {
            throw new ClassCastException("Activity must implement YesNoDialogFragmentListener.");
        }
    }

    public interface YesNoDialogFragmentListener {

        void onYes();
    }
}


text:
package schema

import (
	"reflect"
	"strconv"
)

// List returns a Checker that accepts a slice value with values
// that are processed with the elem checker.  If any element of the
// provided slice value fails to be processed, processing will stop
// and return with the obtained error.
//
// The coerced output value has type []interface{}.
func List(elem Checker) Checker {
	return listC{elem}
}

type listC struct {
	elem Checker
}

func (c listC) Coerce(v interface{}, path []string) (interface{}, error) {
	rv := reflect.ValueOf(v)
	if rv.Kind() != reflect.Slice {
		return nil, error_{"list", v, path}
	}

	path = append(path, "[", "?", "]")

	l := rv.Len()
	out := make([]interface{}, 0, l)
	for i := 0; i != l; i++ {
		path[len(path)-2] = strconv.Itoa(i)
		elem, err := c.elem.Coerce(rv.Index(i).Interface(), path)
		if err != nil {
			return nil, err
		}
		out = append(out, elem)
	}
	return out, nil
}


text:
using System.Fabric;
using FG.ServiceFabric.Diagnostics;
using Microsoft.ServiceFabric.Services.Communication.Runtime;
using Microsoft.ServiceFabric.Services.Remoting;
using Microsoft.ServiceFabric.Services.Remoting.FabricTransport.Runtime;
using Microsoft.ServiceFabric.Services.Remoting.Runtime;

namespace FG.ServiceFabric.Services.Remoting.Runtime
{
    public static class ServiceListenerExtensions
    {
        public static ServiceReplicaListener CreateServiceReplicaListener(this IService service, ServiceContext context, IServiceCommunicationLogger logger)
        {
            return new ServiceReplicaListener(ctxt =>
                (IServiceRemotingListener)new FabricTransportServiceRemotingListener(
                    serviceContext: ctxt,
                    messageHandler: new ServiceRemotingDispatcher(
                        service: service,
                        innerMessageHandler: new Microsoft.ServiceFabric.Services.Remoting.Runtime.ServiceRemotingDispatcher(context, service),
                        logger: logger),
                    listenerSettings: new FabricTransportRemotingListenerSettings()
                    {
                        MaxConcurrentCalls = 1000,
                    }
                ));
        }
    }
}


text:
package net.sourceforge.plantuml.creole.legacy;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

import net.sourceforge.plantuml.BackSlash;
import net.sourceforge.plantuml.LineBreakStrategy;
import net.sourceforge.plantuml.Log;
import net.sourceforge.plantuml.StringUtils;
import net.sourceforge.plantuml.Url;
import net.sourceforge.plantuml.awt.geom.XDimension2D;
import net.sourceforge.plantuml.creole.atom.AbstractAtom;
import net.sourceforge.plantuml.creole.atom.Atom;
import net.sourceforge.plantuml.graphic.FontConfiguration;
import net.sourceforge.plantuml.graphic.StringBounder;
import net.sourceforge.plantuml.graphic.TextBlock;
import net.sourceforge.plantuml.ugraphic.UGraphic;
import net.sourceforge.plantuml.ugraphic.UText;
import net.sourceforge.plantuml.ugraphic.UTranslate;
import net.sourceforge.plantuml.ugraphic.color.HColor;
import net.sourceforge.plantuml.utils.CharHidder;

public final class AtomText extends AbstractAtom implements Atom {

	protected interface DelayedDouble {
		public double getDouble(StringBounder stringBounder);
	}

	private final FontConfiguration fontConfiguration;
	private final String text;
	private final DelayedDouble marginLeft;
	private final DelayedDouble marginRight;
	private final Url url;
	private final boolean manageSpecialChars;
	private TextBlock visibility;

	protected AtomText(String text, FontConfiguration style, Url url, DelayedDouble marginLeft,
			DelayedDouble marginRight, boolean manageSpecialChars) {
		if (text.contains("" + BackSlash.hiddenNewLine()))
			throw new IllegalArgumentException(text);

//		if (text.length() > 0) {
//			final VisibilityModifier visibilityModifier = VisibilityModifier.getByUnicode(text.charAt(0));
//			if (visibilityModifier != null) {
//				final HColor back = HColorUtils.GREEN;
//				final HColor fore = HColorUtils.RED;
//				visibility = visibilityModifier.getUBlock(11, fore, back, url != null);
//				text = text.substring(1);
//			}
//		}

		this.marginLeft = marginLeft;
		this.marginRight = marginRight;
		String s = CharHidder.unhide(text);
		if (manageSpecialChars) {
			s = StringUtils.showComparatorCharacters(s);
			s = StringUtils.manageAmpDiese(s);
			s = StringUtils.manageUnicodeNotationUplus(s);
			s = StringUtils.manageTildeArobaseStart(s);
			s = StringUtils.manageEscapedTabs(s);
		}
		this.manageSpecialChars = manageSpecialChars;
		this.text = s;
		this.fontConfiguration = style;
		this.url = url;
	}

	private AtomText withText(String text) {
		return new AtomText(text, fontConfiguration, url, marginLeft, marginRight, manageSpecialChars);
	}

	public XDimension2D calculateDimension(StringBounder stringBounder) {
		final XDimension2D rect = stringBounder.calculateDimension(fontConfiguration.getFont(), text);
		Log.debug("g2d=" + rect);
		Log.debug("Size for " + text + " is " + rect);
		double h = rect.getHeight();
		if (h < 10)
			h = 10;

		double width = text.indexOf("\t") == -1 ? rect.getWidth() : getWidth(stringBounder, text);
		final double left = marginLeft.getDouble(stringBounder);
		final double right = marginRight.getDouble(stringBounder);
		if (visibility != null)
			width += visibility.calculateDimension(stringBounder).getWidth();

		return new XDimension2D(width + left + right, h);
	}

	public void drawU(UGraphic ug) {
		if (url != null)
			ug.startUrl(url);

		if (ug.matchesProperty("SPECIALTXT")) {
			ug.draw(this);
		} else {
			if (visibility != null) {
				visibility.drawU(ug.apply(UTranslate.dy(2)));
				final double width = visibility.calculateDimension(ug.getStringBounder()).getWidth();
				ug = ug.apply(UTranslate.dx(width));
			}
			HColor textColor = fontConfiguration.getColor();
			FontConfiguration useFontConfiguration = fontConfiguration;

			HColor backcolor = ug.getParam().getBackcolor();
			if (backcolor.isTransparent())
				backcolor = ug.getDefaultBackground();

			textColor = textColor.getAppropriateColor(backcolor);
			useFontConfiguration = fontConfiguration.changeColor(textColor);

			if (marginLeft != AtomTextUtils.ZERO)
				ug = ug.apply(UTranslate.dx(marginLeft.getDouble(ug.getStringBounder())));

			final StringTokenizer tokenizer = new StringTokenizer(text, "\t", true);

			// final int ypos = fontConfiguration.getSpace();
			final XDimension2D rect = ug.getStringBounder().calculateDimension(fontConfiguration.getFont(), text);
			final double descent = getDescent(ug.getStringBounder());
			final double ypos = rect.getHeight() - descent;

			double x = 0;
			if (tokenizer.hasMoreTokens()) {
				final double tabSize = getTabSize(ug.getStringBounder());
				while (tokenizer.hasMoreTokens()) {
					final String s = tokenizer.nextToken();
					if (s.equals("\t")) {
						final double remainder = x % tabSize;
						x += tabSize - remainder;
					} else {
						final XDimension2D dim = ug.getStringBounder().calculateDimension(fontConfiguration.getFont(),
								s);
						final UText utext = new UText(s, useFontConfiguration);
						ug.apply(new UTranslate(x, ypos)).draw(utext);
						x += dim.getWidth();
					}
				}
			}
		}
		if (url != null)
			ug.closeUrl();

	}

	private double getWidth(StringBounder stringBounder, String text) {
		final StringTokenizer tokenizer = new StringTokenizer(text, "\t", true);
		final double tabSize = getTabSize(stringBounder);
		double x = 0;
		while (tokenizer.hasMoreTokens()) {
			final String s = tokenizer.nextToken();
			if (s.equals("\t")) {
				final double remainder = x % tabSize;
				x += tabSize - remainder;
			} else {
				final XDimension2D dim = stringBounder.calculateDimension(fontConfiguration.getFont(), s);
				x += dim.getWidth();
			}
		}
		return x;
	}

	private String tabString() {
		final int nb = fontConfiguration.getTabSize();
		if (nb >= 1 && nb < 7)
			return "        ".substring(0, nb);

		return "        ";
	}

	private double getDescent(StringBounder stringBounder) {
		return stringBounder.getDescent(fontConfiguration.getFont(), text);
	}

	private double getTabSize(StringBounder stringBounder) {
		return stringBounder.calculateDimension(fontConfiguration.getFont(), tabString()).getWidth();
	}

	private final Collection<String> splitted() {
		final List<String> result = new ArrayList<>();
		final StringBuilder pending = new StringBuilder();
		for (int i = 0; i < text.length(); i++) {
			final char ch = text.charAt(i);
			if (isSeparator(ch)) {
				if (pending.length() > 0)
					result.add(pending.toString());
				result.add("" + ch);
				pending.setLength(0);
			} else if (isChineseSentenceBoundary(ch)) {
				pending.append(ch);
				result.add(pending.toString());
				pending.setLength(0);
			} else {
				pending.append(ch);
			}
		}
		if (pending.length() > 0)
			result.add(pending.toString());
		return result;
	}

	private final Collection<String> splittedOld() {
		final List<String> result = new ArrayList<>();
		for (int i = 0; i < text.length(); i++) {
			final char ch = text.charAt(i);
			if (isSeparator(ch)) {
				result.add("" + text.charAt(i));
			} else {
				final StringBuilder tmp = new StringBuilder();
				tmp.append(ch);
				while (i + 1 < text.length() && isSeparator(text.charAt(i + 1)) == false) {
					i++;
					tmp.append(text.charAt(i));
				}
				result.add(tmp.toString());
			}
		}
		return result;
	}

	public List<Atom> getSplitted(StringBounder stringBounder, LineBreakStrategy maxWidthAsString) {
		final double maxWidth = maxWidthAsString.getMaxWidth();
		if (maxWidth == 0)
			throw new IllegalStateException();

		final List<Atom> result = new ArrayList<>();
		final StringTokenizer st = new StringTokenizer(text, " ", true);
		final StringBuilder currentLine = new StringBuilder();
		while (st.hasMoreTokens()) {
			final String token1 = st.nextToken();
			for (String tmp : Arrays.asList(token1)) {
				final double w = getWidth(stringBounder, currentLine + tmp);
				if (w > maxWidth) {
					result.add(withText(currentLine.toString()));
					currentLine.setLength(0);
					if (tmp.startsWith(" ") == false)
						currentLine.append(tmp);

				} else {
					currentLine.append(tmp);
				}
			}
		}
		result.add(withText(currentLine.toString()));
		return Collections.unmodifiableList(result);
	}

	@Override
	public List<Atom> splitInTwo(StringBounder stringBounder, double width) {
		final StringBuilder tmp = new StringBuilder();
		for (String token : splitted()) {
			if (tmp.length() > 0 && getWidth(stringBounder, tmp.toString() + token) > width) {
				final Atom part1 = withText(tmp.toString());
				String remain = text.substring(tmp.length());
				while (remain.startsWith(" "))
					remain = remain.substring(1);

				final Atom part2 = withText(remain);
				return Arrays.asList(part1, part2);
			}
			tmp.append(token);
		}
		return Collections.singletonList((Atom) this);
	}

	private boolean isSeparator(char ch) {
		return Character.isWhitespace(ch);
	}

	private boolean isChineseSentenceBoundary(char ch) {
		return ch == '\uFF01' // U+FF01 FULLWIDTH EXCLAMATION MARK (!)
//				|| ch == '\uFF08' // U+FF08 FULLWIDTH LEFT PARENTHESIS
//				|| ch == '\uFF09' // U+FF09 FULLWIDTH RIGHT PARENTHESIS
				|| ch == '\uFF0C' // U+FF0C FULLWIDTH COMMA
				|| ch == '\uFF1A' // U+FF1A FULLWIDTH COLON (:)
				|| ch == '\uFF1B' // U+FF1B FULLWIDTH SEMICOLON (;)
				|| ch == '\uFF1F' // U+FF1F FULLWIDTH QUESTION MARK (?)
				|| ch == '\u3002'; // U+3002 IDEOGRAPHIC FULL STOP (.)
	}

	public final String getText() {
		return text;
	}

	public double getStartingAltitude(StringBounder stringBounder) {
		return fontConfiguration.getSpace();
	}

	@Override
	public String toString() {
		return text + " " + fontConfiguration;
	}

	public FontConfiguration getFontConfiguration() {
		return fontConfiguration;
	}

}


text:
package tips

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

// ListFiles lists the files in the current directory.
// Uses directory "serverless_function_source_code" as defined in the Go
// Functions Framework Buildpack.
// See https://github.com/GoogleCloudPlatform/buildpacks/blob/56eaad4dfe6c7bd0ecc4a175de030d2cfab9ae1c/cmd/go/functions_framework/main.go#L38.
func ListFiles(w http.ResponseWriter, r *http.Request) {
	files, err := ioutil.ReadDir("./serverless_function_source_code")
	if err != nil {
		http.Error(w, "Unable to read files", http.StatusInternalServerError)
		log.Printf("ioutil.ListFiles: %v", err)
		return
	}
	fmt.Fprintln(w, "Files:")
	for _, f := range files {
		fmt.Fprintf(w, "\t%v\n", f.Name())
	}
}

// [END functions_concepts_filesystem]


text:
function failed {
	printf "format_mount test suite FAILED\n" >&1
	exit 1
}

touch /var/lib/docker/foo || failed

printf "format_mount test suite PASSED\n" >&1