text:
require "optparse"
require "rbconfig"
require "leakchecker"

##
# Minimal (mostly drop-in) replacement for test-unit.
#
# :include: README.txt

module MiniTest

  def self.const_missing name # :nodoc:
    case name
    when :MINI_DIR then
      msg = "MiniTest::MINI_DIR was removed. Don't violate other's internals."
      warn "WAR\NING: #{msg}"
      warn "WAR\NING: Used by #{caller.first}."
      const_set :MINI_DIR, "bad value"
    else
      super
    end
  end

  ##
  # Assertion base class

  class Assertion < Exception; end

  ##
  # Assertion raised when skipping a test

  class Skip < Assertion; end

  class << self
    ##
    # Filter object for backtraces.

    attr_accessor :backtrace_filter
  end

  class BacktraceFilter # :nodoc:
    def filter bt
      return ["No backtrace"] unless bt

      new_bt = []

      unless $DEBUG then
        bt.each do |line|
          break if line =~ /lib\/minitest/
          new_bt << line
        end

        new_bt = bt.reject { |line| line =~ /lib\/minitest/ } if new_bt.empty?
        new_bt = bt.dup if new_bt.empty?
      else
        new_bt = bt.dup
      end

      new_bt
    end
  end

  self.backtrace_filter = BacktraceFilter.new

  def self.filter_backtrace bt # :nodoc:
    backtrace_filter.filter bt
  end

  ##
  # MiniTest Assertions.  All assertion methods accept a +msg+ which is
  # printed if the assertion fails.

  module Assertions
    ##
    # Returns the diff command to use in #diff. Tries to intelligently
    # figure out what diff to use.

    def self.diff
      unless defined? @diff
        exe = RbConfig::CONFIG['EXEEXT']
        @diff = %W"gdiff#{exe} diff#{exe}".find do |diff|
          if system(diff, "-u", __FILE__, __FILE__)
            break "#{diff} -u"
          end
        end
      end

      @diff
    end

    ##
    # Set the diff command to use in #diff.

    def self.diff= o
      @diff = o
    end

    ##
    # Returns a diff between +exp+ and +act+. If there is no known
    # diff command or if it doesn't make sense to diff the output
    # (single line, short output), then it simply returns a basic
    # comparison between the two.

    def diff exp, act
      require "tempfile"

      expect = mu_pp_for_diff exp
      butwas = mu_pp_for_diff act
      result = nil

      need_to_diff =
        MiniTest::Assertions.diff &&
        (expect.include?("\n")    ||
         butwas.include?("\n")    ||
         expect.size > 30         ||
         butwas.size > 30         ||
         expect == butwas)

      return "Expected: #{mu_pp exp}\n  Actual: #{mu_pp act}" unless
        need_to_diff

      tempfile_a = nil
      tempfile_b = nil

      Tempfile.open("expect") do |a|
        tempfile_a = a
        a.puts expect
        a.flush

        Tempfile.open("butwas") do |b|
          tempfile_b = b
          b.puts butwas
          b.flush

          result = `#{MiniTest::Assertions.diff} #{a.path} #{b.path}`
          result.sub!(/^\-\-\- .+/, "--- expected")
          result.sub!(/^\+\+\+ .+/, "+++ actual")

          if result.empty? then
            klass = exp.class
            result = [
                      "No visible difference in the #{klass}#inspect output.\n",
                      "You should look at the implementation of #== on ",
                      "#{klass} or its members.\n",
                      expect,
                     ].join
          end
        end
      end

      result
    ensure
      tempfile_a.close! if tempfile_a
      tempfile_b.close! if tempfile_b
    end

    ##
    # This returns a human-readable version of +obj+. By default
    # #inspect is called. You can override this to use #pretty_print
    # if you want.

    def mu_pp obj
      s = obj.inspect
      s = s.encode Encoding.default_external if defined? Encoding
      s
    end

    ##
    # This returns a diff-able human-readable version of +obj+. This
    # differs from the regular mu_pp because it expands escaped
    # newlines and makes hex-values generic (like object_ids). This
    # uses mu_pp to do the first pass and then cleans it up.

    def mu_pp_for_diff obj
      mu_pp(obj).gsub(/(?<!\\)(?:\\\\)*\K\\n/, "\n").gsub(/:0x[a-fA-F0-9]{4,}/m, ':0xXXXXXX')
    end

    def _assertions= n # :nodoc:
      @_assertions = n
    end

    def _assertions # :nodoc:
      @_assertions ||= 0
    end

    ##
    # Fails unless +test+ is a true value.

    def assert test, msg = nil
      msg ||= "Failed assertion, no message given."
      self._assertions += 1
      unless test then
        msg = msg.call if Proc === msg
        raise MiniTest::Assertion, msg
      end
      true
    end

    ##
    # Fails unless +obj+ is empty.

    def assert_empty obj, msg = nil
      msg = message(msg) { "Expected #{mu_pp(obj)} to be empty" }
      assert_respond_to obj, :empty?
      assert obj.empty?, msg
    end

    ##
    # Fails unless <tt>exp == act</tt> printing the difference between
    # the two, if possible.
    #
    # If there is no visible difference but the assertion fails, you
    # should suspect that your #== is buggy, or your inspect output is
    # missing crucial details.
    #
    # For floats use assert_in_delta.
    #
    # See also: MiniTest::Assertions.diff

    def assert_equal exp, act, msg = nil
      msg = message(msg, "") { diff exp, act }
      assert exp == act, msg
    end

    ##
    # For comparing Floats.  Fails unless +exp+ and +act+ are within +delta+
    # of each other.
    #
    #   assert_in_delta Math::PI, (22.0 / 7.0), 0.01

    def assert_in_delta exp, act, delta = 0.001, msg = nil
      n = (exp - act).abs
      msg = message(msg) {
        "Expected |#{exp} - #{act}| (#{n}) to be <= #{delta}"
      }
      assert delta >= n, msg
    end

    ##
    # For comparing Floats.  Fails unless +exp+ and +act+ have a relative
    # error less than +epsilon+.

    def assert_in_epsilon a, b, epsilon = 0.001, msg = nil
      assert_in_delta a, b, [a.abs, b.abs].min * epsilon, msg
    end

    ##
    # Fails unless +collection+ includes +obj+.

    def assert_includes collection, obj, msg = nil
      msg = message(msg) {
        "Expected #{mu_pp(collection)} to include #{mu_pp(obj)}"
      }
      assert_respond_to collection, :include?
      assert collection.include?(obj), msg
    end

    ##
    # Fails unless +obj+ is an instance of +cls+.

    def assert_instance_of cls, obj, msg = nil
      msg = message(msg) {
        "Expected #{mu_pp(obj)} to be an instance of #{cls}, not #{obj.class}"
      }

      assert obj.instance_of?(cls), msg
    end

    ##
    # Fails unless +obj+ is a kind of +cls+.

    def assert_kind_of cls, obj, msg = nil # TODO: merge with instance_of
      msg = message(msg) {
        "Expected #{mu_pp(obj)} to be a kind of #{cls}, not #{obj.class}" }

      assert obj.kind_of?(cls), msg
    end

    ##
    # Fails unless +matcher+ <tt>=~</tt> +obj+.

    def assert_match matcher, obj, msg = nil
      msg = message(msg) { "Expected #{mu_pp matcher} to match #{mu_pp obj}" }
      assert_respond_to matcher, :"=~"
      matcher = Regexp.new Regexp.escape matcher if String === matcher
      assert matcher =~ obj, msg
    end

    ##
    # Fails unless +obj+ is nil

    def assert_nil obj, msg = nil
      msg = message(msg) { "Expected #{mu_pp(obj)} to be nil" }
      assert obj.nil?, msg
    end

    ##
    # For testing with binary operators.
    #
    #   assert_operator 5, :<=, 4

    def assert_operator o1, op, o2 = (predicate = true; nil), msg = nil
      return assert_predicate o1, op, msg if predicate
      msg = message(msg) { "Expected #{mu_pp(o1)} to be #{op} #{mu_pp(o2)}" }
      assert o1.__send__(op, o2), msg
    end

    ##
    # Fails if stdout or stderr do not output the expected results.
    # Pass in nil if you don't care about that streams output. Pass in
    # "" if you require it to be silent. Pass in a regexp if you want
    # to pattern match.
    #
    # NOTE: this uses #capture_io, not #capture_subprocess_io.
    #
    # See also: #assert_silent

    def assert_output stdout = nil, stderr = nil
      out, err = capture_io do
        yield
      end

      err_msg = Regexp === stderr ? :assert_match : :assert_equal if stderr
      out_msg = Regexp === stdout ? :assert_match : :assert_equal if stdout

      y = send err_msg, stderr, err, "In stderr" if err_msg
      x = send out_msg, stdout, out, "In stdout" if out_msg

      (!stdout || x) && (!stderr || y)
    end

    ##
    # For testing with predicates.
    #
    #   assert_predicate str, :empty?
    #
    # This is really meant for specs and is front-ended by assert_operator:
    #
    #   str.must_be :empty?

    def assert_predicate o1, op, msg = nil
      msg = message(msg) { "Expected #{mu_pp(o1)} to be #{op}" }
      assert o1.__send__(op), msg
    end

    ##
    # Fails unless the block raises one of +exp+. Returns the
    # exception matched so you can check the message, attributes, etc.

    def assert_raises *exp
      msg = "#{exp.pop}.\n" if String === exp.last

      begin
        yield
      rescue MiniTest::Skip => e
        return e if exp.include? MiniTest::Skip
        raise e
      rescue Exception => e
        expected = exp.any? { |ex|
          if ex.instance_of? Module then
            e.kind_of? ex
          else
            e.instance_of? ex
          end
        }

        assert expected, proc {
          exception_details(e, "#{msg}#{mu_pp(exp)} exception expected, not")
        }

        return e
      end

      exp = exp.first if exp.size == 1

      flunk "#{msg}#{mu_pp(exp)} expected but nothing was raised."
    end

    ##
    # Fails unless +obj+ responds to +meth+.

    def assert_respond_to obj, meth, msg = nil
      msg = message(msg) {
        "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}"
      }
      assert obj.respond_to?(meth), msg
    end

    ##
    # Fails unless +exp+ and +act+ are #equal?

    def assert_same exp, act, msg = nil
      msg = message(msg) {
        data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id]
        "Expected %s (oid=%d) to be the same as %s (oid=%d)" % data
      }
      assert exp.equal?(act), msg
    end

    ##
    # +send_ary+ is a receiver, message and arguments.
    #
    # Fails unless the call returns a true value
    # TODO: I should prolly remove this from specs

    def assert_send send_ary, m = nil
      recv, msg, *args = send_ary
      m = message(m) {
        "Expected #{mu_pp(recv)}.#{msg}(*#{mu_pp(args)}) to return true" }
      assert recv.__send__(msg, *args), m
    end

    ##
    # Fails if the block outputs anything to stderr or stdout.
    #
    # See also: #assert_output

    def assert_silent
      assert_output "", "" do
        yield
      end
    end

    ##
    # Fails unless the block throws +sym+

    def assert_throws sym, msg = nil
      default = "Expected #{mu_pp(sym)} to have been thrown"
      caught = true
      catch(sym) do
        begin
          yield
        rescue ThreadError => e       # wtf?!? 1.8 + threads == suck
          default += ", not \:#{e.message[/uncaught throw \`(\w+?)\'/, 1]}"
        rescue ArgumentError => e     # 1.9 exception
          default += ", not #{e.message.split(/ /).last}"
        rescue NameError => e         # 1.8 exception
          default += ", not #{e.name.inspect}"
        end
        caught = false
      end

      assert caught, message(msg) { default }
    end

    ##
    # Captures $stdout and $stderr into strings:
    #
    #   out, err = capture_io do
    #     puts "Some info"
    #     warn "You did a bad thing"
    #   end
    #
    #   assert_match %r%info%, out
    #   assert_match %r%bad%, err
    #
    # NOTE: For efficiency, this method uses StringIO and does not
    # capture IO for subprocesses. Use #capture_subprocess_io for
    # that.

    def capture_io
      require 'stringio'

      captured_stdout, captured_stderr = StringIO.new, StringIO.new

      synchronize do
        orig_stdout, orig_stderr = $stdout, $stderr
        $stdout, $stderr         = captured_stdout, captured_stderr

        begin
          yield
        ensure
          $stdout = orig_stdout
          $stderr = orig_stderr
        end
      end

      return captured_stdout.string, captured_stderr.string
    end
    alias capture_output capture_io

    ##
    # Captures $stdout and $stderr into strings, using Tempfile to
    # ensure that subprocess IO is captured as well.
    #
    #   out, err = capture_subprocess_io do
    #     system "echo Some info"
    #     system "echo You did a bad thing 1>&2"
    #   end
    #
    #   assert_match %r%info%, out
    #   assert_match %r%bad%, err
    #
    # NOTE: This method is approximately 10x slower than #capture_io so
    # only use it when you need to test the output of a subprocess.

    def capture_subprocess_io
      require 'tempfile'

      captured_stdout, captured_stderr = Tempfile.new("out"), Tempfile.new("err")

      synchronize do
        orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
        $stdout.reopen captured_stdout
        $stderr.reopen captured_stderr

        begin
          yield

          $stdout.rewind
          $stderr.rewind

          [captured_stdout.read, captured_stderr.read]
        ensure
          $stdout.reopen orig_stdout
          $stderr.reopen orig_stderr
          orig_stdout.close
          orig_stderr.close
          captured_stdout.close!
          captured_stderr.close!
        end
      end
    end

    ##
    # Returns details for exception +e+

    def exception_details e, msg
      [
       "#{msg}",
       "Class: <#{e.class}>",
       "Message: <#{e.message.inspect}>",
       "---Backtrace---",
       "#{MiniTest::filter_backtrace(e.backtrace).join("\n")}",
       "---------------",
      ].join "\n"
    end

    ##
    # Fails with +msg+

    def flunk msg = nil
      msg ||= "Epic Fail!"
      assert false, msg
    end

    ##
    # Returns a proc that will output +msg+ along with the default message.

    def message msg = nil, ending = ".", &default
      proc {
        msg = msg.call.chomp(".") if Proc === msg
        custom_message = "#{msg}.\n" unless msg.nil? or msg.to_s.empty?
        "#{custom_message}#{default.call}#{ending}"
      }
    end

    ##
    # used for counting assertions

    def pass msg = nil
      assert true
    end

    ##
    # Fails if +test+ is a true value

    def refute test, msg = nil
      msg ||= "Failed refutation, no message given"
      not assert(! test, msg)
    end

    ##
    # Fails if +obj+ is empty.

    def refute_empty obj, msg = nil
      msg = message(msg) { "Expected #{mu_pp(obj)} to not be empty" }
      assert_respond_to obj, :empty?
      refute obj.empty?, msg
    end

    ##
    # Fails if <tt>exp == act</tt>.
    #
    # For floats use refute_in_delta.

    def refute_equal exp, act, msg = nil
      msg = message(msg) {
        "Expected #{mu_pp(act)} to not be equal to #{mu_pp(exp)}"
      }
      refute exp == act, msg
    end

    ##
    # For comparing Floats.  Fails if +exp+ is within +delta+ of +act+.
    #
    #   refute_in_delta Math::PI, (22.0 / 7.0)

    def refute_in_delta exp, act, delta = 0.001, msg = nil
      n = (exp - act).abs
      msg = message(msg) {
        "Expected |#{exp} - #{act}| (#{n}) to not be <= #{delta}"
      }
      refute delta >= n, msg
    end

    ##
    # For comparing Floats.  Fails if +exp+ and +act+ have a relative error
    # less than +epsilon+.

    def refute_in_epsilon a, b, epsilon = 0.001, msg = nil
      refute_in_delta a, b, a * epsilon, msg
    end

    ##
    # Fails if +collection+ includes +obj+.

    def refute_includes collection, obj, msg = nil
      msg = message(msg) {
        "Expected #{mu_pp(collection)} to not include #{mu_pp(obj)}"
      }
      assert_respond_to collection, :include?
      refute collection.include?(obj), msg
    end

    ##
    # Fails if +obj+ is an instance of +cls+.

    def refute_instance_of cls, obj, msg = nil
      msg = message(msg) {
        "Expected #{mu_pp(obj)} to not be an instance of #{cls}"
      }
      refute obj.instance_of?(cls), msg
    end

    ##
    # Fails if +obj+ is a kind of +cls+.

    def refute_kind_of cls, obj, msg = nil # TODO: merge with instance_of
      msg = message(msg) { "Expected #{mu_pp(obj)} to not be a kind of #{cls}" }
      refute obj.kind_of?(cls), msg
    end

    ##
    # Fails if +matcher+ <tt>=~</tt> +obj+.

    def refute_match matcher, obj, msg = nil
      msg = message(msg) {"Expected #{mu_pp matcher} to not match #{mu_pp obj}"}
      assert_respond_to matcher, :"=~"
      matcher = Regexp.new Regexp.escape matcher if String === matcher
      refute matcher =~ obj, msg
    end

    ##
    # Fails if +obj+ is nil.

    def refute_nil obj, msg = nil
      msg = message(msg) { "Expected #{mu_pp(obj)} to not be nil" }
      refute obj.nil?, msg
    end

    ##
    # Fails if +o1+ is not +op+ +o2+. Eg:
    #
    #   refute_operator 1, :>, 2 #=> pass
    #   refute_operator 1, :<, 2 #=> fail

    def refute_operator o1, op, o2 = (predicate = true; nil), msg = nil
      return refute_predicate o1, op, msg if predicate
      msg = message(msg) { "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}"}
      refute o1.__send__(op, o2), msg
    end

    ##
    # For testing with predicates.
    #
    #   refute_predicate str, :empty?
    #
    # This is really meant for specs and is front-ended by refute_operator:
    #
    #   str.wont_be :empty?

    def refute_predicate o1, op, msg = nil
      msg = message(msg) { "Expected #{mu_pp(o1)} to not be #{op}" }
      refute o1.__send__(op), msg
    end

    ##
    # Fails if +obj+ responds to the message +meth+.

    def refute_respond_to obj, meth, msg = nil
      msg = message(msg) { "Expected #{mu_pp(obj)} to not respond to #{meth}" }

      refute obj.respond_to?(meth), msg
    end

    ##
    # Fails if +exp+ is the same (by object identity) as +act+.

    def refute_same exp, act, msg = nil
      msg = message(msg) {
        data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id]
        "Expected %s (oid=%d) to not be the same as %s (oid=%d)" % data
      }
      refute exp.equal?(act), msg
    end

    ##
    # Skips the current test. Gets listed at the end of the run but
    # doesn't cause a failure exit code.

    def skip msg = nil, bt = caller
      msg ||= "Skipped, no message given"
      @skip = true
      raise MiniTest::Skip, msg, bt
    end

    alias omit skip

    ##
    # Was this testcase skipped? Meant for #teardown.

    def skipped?
      defined?(@skip) and @skip
    end

    ##
    # Takes a block and wraps it with the runner's shared mutex.

    def synchronize
      Minitest::Unit.runner.synchronize do
        yield
      end
    end
  end

  class Unit # :nodoc:
    VERSION = "4.7.5" # :nodoc:

    attr_accessor :report, :failures, :errors, :skips # :nodoc:
    attr_accessor :assertion_count                    # :nodoc:
    attr_writer   :test_count                         # :nodoc:
    attr_accessor :start_time                         # :nodoc:
    attr_accessor :help                               # :nodoc:
    attr_accessor :verbose                            # :nodoc:
    attr_writer   :options                            # :nodoc:

    ##
    # :attr:
    #
    # if true, installs an "INFO" signal handler (only available to BSD and
    # OS X users) which prints diagnostic information about the test run.
    #
    # This is auto-detected by default but may be overridden by custom
    # runners.

    attr_accessor :info_signal

    ##
    # Lazy accessor for options.

    def options
      @options ||= {}
    end

    @@installed_at_exit ||= false
    @@out = $stdout
    @@after_tests = []

    ##
    # A simple hook allowing you to run a block of code after _all_ of
    # the tests are done. Eg:
    #
    #   MiniTest::Unit.after_tests { p $debugging_info }

    def self.after_tests &block
      @@after_tests << block
    end

    ##
    # Registers MiniTest::Unit to run tests at process exit

    def self.autorun
      at_exit {
        # don't run if there was a non-exit exception
        next if $! and not $!.kind_of? SystemExit

        # the order here is important. The at_exit handler must be
        # installed before anyone else gets a chance to install their
        # own, that way we can be assured that our exit will be last
        # to run (at_exit stacks).
        exit_code = nil

        at_exit {
          @@after_tests.reverse_each(&:call)
          exit false if exit_code && exit_code != 0
        }

        exit_code = MiniTest::Unit.new.run ARGV
      } unless @@installed_at_exit
      @@installed_at_exit = true
    end

    ##
    # Returns the stream to use for output.

    def self.output
      @@out
    end

    ##
    # Sets MiniTest::Unit to write output to +stream+.  $stdout is the default
    # output

    def self.output= stream
      @@out = stream
    end

    ##
    # Tells MiniTest::Unit to delegate to +runner+, an instance of a
    # MiniTest::Unit subclass, when MiniTest::Unit#run is called.

    def self.runner= runner
      @@runner = runner
    end

    ##
    # Returns the MiniTest::Unit subclass instance that will be used
    # to run the tests. A MiniTest::Unit instance is the default
    # runner.

    def self.runner
      @@runner ||= self.new
    end

    ##
    # Return all plugins' run methods (methods that start with "run_").

    def self.plugins
      @@plugins ||= (["run_tests"] +
                     public_instance_methods(false).
                     grep(/^run_/).map { |s| s.to_s }).uniq
    end

    ##
    # Return the IO for output.

    def output
      self.class.output
    end

    def puts *a  # :nodoc:
      output.puts(*a)
    end

    def print *a # :nodoc:
      output.print(*a)
    end

    def test_count # :nodoc:
      @test_count ||= 0
    end

    ##
    # Runner for a given +type+ (eg, test vs bench).

    def _run_anything type
      suites = TestCase.send "#{type}_suites"
      return if suites.empty?

      puts
      puts "# Running #{type}s:"
      puts

      @test_count, @assertion_count = 0, 0
      test_count = assertion_count = 0
      sync = output.respond_to? :"sync=" # stupid emacs
      old_sync, output.sync = output.sync, true if sync

      count = 0
      begin
        start = Time.now

        results = _run_suites suites, type

        @test_count      = results.inject(0) { |sum, (tc, _)| sum + tc }
        @assertion_count = results.inject(0) { |sum, (_, ac)| sum + ac }
        test_count      += @test_count
        assertion_count += @assertion_count
        t = Time.now - start
        count += 1
        unless @repeat_count
          puts
          puts
        end
        puts "Finished%s %ss in %.6fs, %.4f tests/s, %.4f assertions/s.\n" %
             [(@repeat_count ? "(#{count}/#{@repeat_count}) " : ""), type,
               t, @test_count.fdiv(t), @assertion_count.fdiv(t)]
      end while @repeat_count && count < @repeat_count &&
                report.empty? && failures.zero? && errors.zero?

      output.sync = old_sync if sync

      report.each_with_index do |msg, i|
        puts "\n%3d) %s" % [i + 1, msg]
      end

      puts
      @test_count      = test_count
      @assertion_count = assertion_count

      status
    end

    ##
    # Runs all the +suites+ for a given +type+.
    #

    def _run_suites suites, type
      suites.map { |suite| _run_suite suite, type }
    end

    ##
    # Run a single +suite+ for a given +type+.

    def _run_suite suite, type
      header = "#{type}_suite_header"
      puts send(header, suite) if respond_to? header

      filter = options[:filter] || '/./'
      filter = Regexp.new $1 if filter =~ /\/(.*)\//

      all_test_methods = suite.send "#{type}_methods"

      filtered_test_methods = all_test_methods.find_all { |m|
        filter === m || filter === "#{suite}##{m}"
      }

      leakchecker = LeakChecker.new

      continuation = proc do
        assertions = filtered_test_methods.map { |method|
          inst = suite.new method
          inst._assertions = 0

          print "#{suite}##{method} = " if @verbose

          start_time = Time.now if @verbose
          result = inst.run self

          print "%.2f s = " % (Time.now - start_time) if @verbose
          print result
          puts if @verbose
          $stdout.flush

          unless defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? # compiler process is wrongly considered as leak
            leakchecker.check("#{inst.class}\##{inst.__name__}")
          end

          inst._assertions
        }
        return assertions.size, assertions.inject(0) { |sum, n| sum + n }
      end

      if ENV["LEAK_CHECKER_TRACE_OBJECT_ALLOCATION"]
        require "objspace"
        ObjectSpace.trace_object_allocations(&continuation)
      else
        continuation.call
      end
    end

    ##
    # Record the result of a single test. Makes it very easy to gather
    # information. Eg:
    #
    #   class StatisticsRecorder < MiniTest::Unit
    #     def record suite, method, assertions, time, error
    #       # ... record the results somewhere ...
    #     end
    #   end
    #
    #   MiniTest::Unit.runner = StatisticsRecorder.new
    #
    # NOTE: record might be sent more than once per test.  It will be
    # sent once with the results from the test itself.  If there is a
    # failure or error in teardown, it will be sent again with the
    # error or failure.

    def record suite, method, assertions, time, error
    end

    def location e # :nodoc:
      last_before_assertion = ""

      return '<empty>' unless e.backtrace # SystemStackError can return nil.

      e.backtrace.reverse_each do |s|
        break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
        last_before_assertion = s
      end
      last_before_assertion.sub(/:in .*$/, '')
    end

    ##
    # Writes status for failed test +meth+ in +klass+ which finished with
    # exception +e+

    def puke klass, meth, e
      e = case e
          when MiniTest::Skip then
            @skips += 1
            return "S" unless @verbose
            "Skipped:\n#{klass}##{meth} [#{location e}]:\n#{e.message}\n"
          when MiniTest::Assertion then
            @failures += 1
            "Failure:\n#{klass}##{meth} [#{location e}]:\n#{e.message}\n"
          else
            @errors += 1
            bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
            "Error:\n#{klass}##{meth}:\n#{e.class}: #{e.message.b}\n    #{bt}\n"
          end
      @report << e
      e[0, 1]
    end

    def initialize # :nodoc:
      @report = []
      @errors = @failures = @skips = 0
      @verbose = false
      @mutex = Thread::Mutex.new
      @info_signal = Signal.list['INFO']
      @repeat_count = nil
    end

    def synchronize # :nodoc:
      if @mutex then
        @mutex.synchronize { yield }
      else
        yield
      end
    end

    def process_args args = [] # :nodoc:
      options = {}
      orig_args = args.dup

      OptionParser.new do |opts|
        opts.banner  = 'minitest options:'
        opts.version = MiniTest::Unit::VERSION

        opts.on '-h', '--help', 'Display this help.' do
          puts opts
          exit
        end

        opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
          options[:seed] = m.to_i
        end

        opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
          options[:verbose] = true
        end

        opts.on '-n', '--name PATTERN', "Filter test names on pattern (e.g. /foo/)" do |a|
          options[:filter] = a
        end

        opts.parse! args
        orig_args -= args
      end

      unless options[:seed] then
        srand
        options[:seed] = srand % 0xFFFF
        orig_args << "--seed" << options[:seed].to_s
      end

      srand options[:seed]

      self.verbose = options[:verbose]
      @help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "

      options
    end

    ##
    # Begins the full test run. Delegates to +runner+'s #_run method.

    def run args = []
      self.class.runner._run(args)
    end

    ##
    # Top level driver, controls all output and filtering.

    def _run args = []
      args = process_args args # ARGH!! blame test/unit process_args
      self.options.merge! args

      puts "Run options: #{help}"

      self.class.plugins.each do |plugin|
        send plugin
        break unless report.empty?
      end

      return failures + errors if self.test_count > 0 # or return nil...
    rescue Interrupt
      abort 'Interrupted'
    end

    ##
    # Runs test suites matching +filter+.

    def run_tests
      _run_anything :test
    end

    ##
    # Writes status to +io+

    def status io = self.output
      format = "%d tests, %d assertions, %d failures, %d errors, %d skips"
      io.puts format % [test_count, assertion_count, failures, errors, skips]
    end

    ##
    # Provides a simple set of guards that you can use in your tests
    # to skip execution if it is not applicable. These methods are
    # mixed into TestCase as both instance and class methods so you
    # can use them inside or outside of the test methods.
    #
    #   def test_something_for_mri
    #     skip "bug 1234"  if jruby?
    #     # ...
    #   end
    #
    #   if windows? then
    #     # ... lots of test methods ...
    #   end

    module Guard

      ##
      # Is this running on jruby?

      def jruby? platform = RUBY_PLATFORM
        "java" == platform
      end

      ##
      # Is this running on mri?

      def maglev? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
        "maglev" == platform
      end

      module_function :maglev?

      ##
      # Is this running on mri?

      def mri? platform = RUBY_DESCRIPTION
        /^ruby/ =~ platform
      end

      ##
      # Is this running on rubinius?

      def rubinius? platform = defined?(RUBY_ENGINE) && RUBY_ENGINE
        "rbx" == platform
      end

      ##
      # Is this running on windows?

      def windows? platform = RUBY_PLATFORM
        /mswin|mingw/ =~ platform
      end

      ##
      # Is this running on mingw?

      def mingw? platform = RUBY_PLATFORM
        /mingw/ =~ platform
      end

    end

    ##
    # Provides before/after hooks for setup and teardown. These are
    # meant for library writers, NOT for regular test authors. See
    # #before_setup for an example.

    module LifecycleHooks
      ##
      # Runs before every test, after setup. This hook is meant for
      # libraries to extend minitest. It is not meant to be used by
      # test developers.
      #
      # See #before_setup for an example.

      def after_setup; end

      ##
      # Runs before every test, before setup. This hook is meant for
      # libraries to extend minitest. It is not meant to be used by
      # test developers.
      #
      # As a simplistic example:
      #
      #   module MyMinitestPlugin
      #     def before_setup
      #       super
      #       # ... stuff to do before setup is run
      #     end
      #
      #     def after_setup
      #       # ... stuff to do after setup is run
      #       super
      #     end
      #
      #     def before_teardown
      #       super
      #       # ... stuff to do before teardown is run
      #     end
      #
      #     def after_teardown
      #       # ... stuff to do after teardown is run
      #       super
      #     end
      #   end
      #
      #   class MiniTest::Unit::TestCase
      #     include MyMinitestPlugin
      #   end

      def before_setup; end

      ##
      # Runs after every test, before teardown. This hook is meant for
      # libraries to extend minitest. It is not meant to be used by
      # test developers.
      #
      # See #before_setup for an example.

      def before_teardown; end

      ##
      # Runs after every test, after teardown. This hook is meant for
      # libraries to extend minitest. It is not meant to be used by
      # test developers.
      #
      # See #before_setup for an example.

      def after_teardown; end
    end

    ##
    # Subclass TestCase to create your own tests. Typically you'll want a
    # TestCase subclass per implementation class.
    #
    # See MiniTest::Assertions

    class TestCase
      include LifecycleHooks
      include Guard
      extend Guard

      attr_reader :__name__ # :nodoc:

      PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException,
                                Interrupt, SystemExit] # :nodoc:

      ##
      # Runs the tests reporting the status to +runner+

      def run runner
        trap "INFO" do
          runner.report.each_with_index do |msg, i|
            warn "\n%3d) %s" % [i + 1, msg]
          end
          warn ''
          time = runner.start_time ? Time.now - runner.start_time : 0
          warn "Current Test: %s#%s %.2fs" % [self.class, self.__name__, time]
          runner.status $stderr
        end if runner.info_signal

        start_time = Time.now

        result = ""
        begin
          @passed = nil
          self.before_setup
          self.setup
          self.after_setup
          self.run_test self.__name__
          result = "." unless io?
          time = Time.now - start_time
          runner.record self.class, self.__name__, self._assertions, time, nil
          @passed = true
        rescue *PASSTHROUGH_EXCEPTIONS
          raise
        rescue Exception => e
          @passed = Skip === e
          time = Time.now - start_time
          runner.record self.class, self.__name__, self._assertions, time, e
          result = runner.puke self.class, self.__name__, e
        ensure
          %w{ before_teardown teardown after_teardown }.each do |hook|
            begin
              self.send hook
            rescue *PASSTHROUGH_EXCEPTIONS
              raise
            rescue Exception => e
              @passed = false
              runner.record self.class, self.__name__, self._assertions, time, e
              result = runner.puke self.class, self.__name__, e
            end
          end
          trap 'INFO', 'DEFAULT' if runner.info_signal
        end
        result
      end

      alias :run_test :__send__

      def initialize name # :nodoc:
        @__name__ = name
        @__io__ = nil
        @passed = nil
        @@current = self # FIX: make thread local
      end

      def self.current # :nodoc:
        @@current # FIX: make thread local
      end

      ##
      # Return the output IO object

      def io
        @__io__ = true
        MiniTest::Unit.output
      end

      ##
      # Have we hooked up the IO yet?

      def io?
        @__io__
      end

      def self.reset # :nodoc:
        @@test_suites = {}
      end

      reset

      ##
      # Make diffs for this TestCase use #pretty_inspect so that diff
      # in assert_equal can be more details. NOTE: this is much slower
      # than the regular inspect but much more usable for complex
      # objects.

      def self.make_my_diffs_pretty!
        require 'pp'

        define_method :mu_pp do |o|
          o.pretty_inspect
        end
      end

      def self.inherited klass # :nodoc:
        @@test_suites[klass] = true
        super
      end

      def self.test_order # :nodoc:
        :random
      end

      def self.test_suites # :nodoc:
        @@test_suites.keys.sort_by { |ts| ts.name.to_s }
      end

      def self.test_methods # :nodoc:
        methods = public_instance_methods(true).grep(/^test/).map { |m| m.to_s }

        case self.test_order
        when :parallel
          max = methods.size
          ParallelEach.new methods.sort.sort_by { rand max }
        when :random then
          max = methods.size
          methods.sort.sort_by { rand max }
        when :alpha, :sorted then
          methods.sort
        else
          raise "Unknown test_order: #{self.test_order.inspect}"
        end
      end

      ##
      # Returns true if the test passed.

      def passed?
        @passed
      end

      ##
      # Runs before every test. Use this to set up before each test
      # run.

      def setup; end

      ##
      # Runs after every test. Use this to clean up after each test
      # run.

      def teardown; end

      include MiniTest::Assertions
    end # class TestCase
  end # class Unit

  Test = Unit::TestCase
end # module MiniTest

Minitest = MiniTest # :nodoc: because ugh... I typo this all the time


text:
(function($) {
    'use strict';

    var methods = {
        init: function(settings) {
            var $currentOpt,
                $this = this,
                settingsDefaults = {
                    data: [],
                    dataMethod: undefined,
                    minLength: 1,
                    maxCount: Infinity,
                    extraClass: '',
                    appendTo: undefined,
                    position: true,
                    sort: function(data) {
                        return (this.dataMethod instanceof Function)? data:data.sort();
                    },
                    matcher: function(query, option) {
                        return option.toString().toLowerCase().indexOf(query.toLowerCase()) !== -1;
                    },
                    lookUp: function(data, option) {
                        var options = [];
                        $.each(data, function(idx, val) {
                            options.push(val.toString());
                        });
                        return options.indexOf(option.toString());
                    },
                    renderOption: function(option) {
                        return option.toString();
                    },
                    onOptionSelect: function(query, option) {
                        return option.toString();
                    },
                    onBlur: function(closeCallback) {
                        closeCallback();
                    }
                },
                storedData = $this[0]._ac;

            settings = $.extend(settingsDefaults, settings);
            settings.position = (settings.appendTo)? false:settings.position;

            function createOptionsDiv() {
                var position, $appendDiv, $optionsContainerDiv;
                $optionsContainerDiv = $('
').css('display', 'none');
                if(settings.position) {
                    position = {
                        left: $this.offset().left,
                        top: $this.offset().top + $this.height()
                    };
                    $optionsContainerDiv.css('position', 'relative').css('top', position.top).css('left', position.left).css('zIndex', 1000);
                }
                $optionsContainerDiv.addClass('ac-options').addClass(settings.extraClass);
                $this.attr('data-ac', 'true');
                $optionsContainerDiv.on('mousedown.ac', 'div', chooseOption);
                $appendDiv = (settings.appendTo)? $(settings.appendTo):$('body');
                $appendDiv.append($optionsContainerDiv);
                // settings.data = settings.sort(settings.data);
                // Save
                $this[0]._ac = {
                    settings: settings,
                    $optionsContainerDiv: $optionsContainerDiv
                };
            }
            function onBlur() {
                var settings = $this[0]._ac.settings;
                settings.onBlur(close);
            }
            function chooseOption(event, optIndex) {
                var value, option,
                    query = $this.val(),
                    settings = $this[0]._ac.settings;
                optIndex = optIndex || $(event.target).closest('.ac-opt').attr('data-opt-idx');
                option = settings.data[optIndex];
                value = settings.onOptionSelect(query, option);
                if(value !== undefined) {
                    $this.val(value);
                }
                // computeOptions();
                setTimeout(function() {
                    $this.focus();
                });
            }
            function changeCurrentOpt($other) {
                if($currentOpt) {
                    $currentOpt.removeClass('ac-opt-curr');
                }
                $currentOpt = $other;
                $currentOpt.addClass('ac-opt-curr');
            }
            function keyHandler(event) {
                var prev, next,
                    $optionsContainerDiv = $this[0]._ac.$optionsContainerDiv;
                switch (event.keyCode) {
                    case 38:
                        if(!$currentOpt) {
                            changeCurrentOpt($optionsContainerDiv.children().eq(0));
                            prev = $currentOpt;
                        } else {
                            prev = $currentOpt.prev();
                        }
                        if(prev && prev.hasClass('ac-opt')) {
                            changeCurrentOpt(prev);
                        }
                        break;
                    case 40:
                        if(!$currentOpt) {
                            changeCurrentOpt($optionsContainerDiv.children().eq(0));
                            next = $currentOpt;
                        } else {
                            next = $currentOpt.next();
                        }
                        if(next && next.hasClass('ac-opt')) {
                            changeCurrentOpt(next);
                        }
                        break;
                    case 13:
                        if($currentOpt && $optionsContainerDiv.css('display') !== 'none') {
                            chooseOption(event, $currentOpt.attr('data-opt-idx'));
                        }
                        break;
                    default:
                        computeOptions($this);
                        break;
                }
            }

            if(!storedData) {
                createOptionsDiv();
                computeOptions($this);
                return $this.each(function() {
                    $this.bind('keyup.ac', keyHandler).bind('blur.ac', onBlur);
                });
            }
        },
        destroy: function() {
            return this.each(function() {
                var $this = $(this);
                $this.unbind('.ac');
                $this[0]._ac.$optionsContainerDiv.remove();
                delete $this[0]._ac;
            });
        },
        add: function(options) {
            var $this = this,
                settings = $this[0]._ac.settings;
            function unique(arr) {
                var uniqArr = [];
                $.each(arr, function(idx, el) {
                    if($.inArray(el, uniqArr) === -1) {
                        uniqArr.push(el);
                    }
                });
                return uniqArr;
            }
            options = (options instanceof Array)? options:[options];
            options = unique(options.concat(settings.data));
            // settings.data = settings.sort(options);
            settings.data = options;

            computeOptions($this);
        },
        remove: function(options) {
            var index,
                $this = this,
                settings = $this[0]._ac.settings;
            options = (options instanceof Array)? options:[options];
            $.each(options, function(idx, option) {
                index = settings.lookUp(settings.data, option);
                if(index !== -1) {
                    settings.data.splice(index, 1);
                }
            });

            computeOptions($this);
        }
    };

    $.fn.autocomplete = function(method) {
        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('not-supported');
        }
    };

    function computeOptions($this) {
        var option,
            callback,
            $optionDiv,
            $divs = $(),
            query = $this.val(),
            $optionsContainerDiv = $this[0]._ac.$optionsContainerDiv,
            settings = $this[0]._ac.settings;
        $optionsContainerDiv.empty();
        if(query.length<settings.minLength) {
            close();
            return;
        }
        callback = function(data) {
            // settings.data = settings.sort(data);
            settings.data = data;
            for(var i=0; i<data.length && $divs.length<=settings.maxCount; i++) {
                option = data[i];
                if (settings.dataMethod instanceof Function || settings.matcher(query, option)) {
                    $optionDiv = $('

').addClass('ac-opt');
                    $optionDiv.attr('data-opt-idx', i);
                    $optionDiv.append(settings.renderOption(option));
                    $divs = $divs.add($optionDiv);
                }
            }
            if ($divs.length>0) {
                $optionsContainerDiv.append($divs);
                open();
            } else {
                close();
            }
        };
        if(settings.dataMethod instanceof Function) {
            settings.dataMethod(query, callback);
        } else {
            callback(settings.data);
        }
        function open() {
            var $optionsContainerDiv = $this[0]._ac.$optionsContainerDiv;
            $optionsContainerDiv.show();
            $this.trigger('opened');
        }
        function close() {
            var $optionsContainerDiv = $this[0]._ac.$optionsContainerDiv;
            $optionsContainerDiv.hide();
            $this.trigger('closed');
        }
    }

})(Zepto);

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

        <meta charset="utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
        <title>Houpix Data Analyze</title>
        <meta name="viewport" content="initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0, user-scalable=no">
        <meta name="apple-mobile-web-app-capable" content="yes">
        <meta name="apple-touch-fullscreen" content="yes">
        <meta name="description" content="Houpix Data Analyze System">

        <link href="../../resources/compnents/bootstrap/css/bootstrap.min.css" rel="stylesheet" />
        <link href="../../resources/compnents/bootstrap/css/bootstrap-responsive.min.css" rel="stylesheet" />
        <link href="../../resources/compnents/fontawesome/css/font-awesome.min.css" rel="stylesheet" />
        <link href="../../resources/compnents/css/styles.css" rel="stylesheet" />

        <link rel="apple-touch-icon-precomposed" sizes="144x144" href="../../resources/compnents/ico/apple-touch-icon-144-precomposed.png">
        <link rel="apple-touch-icon-precomposed" sizes="114x114" href="../../resources/compnents/ico/apple-touch-icon-114-precomposed.png">
        <link rel="apple-touch-icon-precomposed" sizes="72x72" href="../../resources/compnents/ico/apple-touch-icon-72-precomposed.png">
        <link rel="apple-touch-icon-precomposed" href="../../resources/compnents/ico/apple-touch-icon-57-precomposed.png">
        <link rel="shortcut icon" href="../../resources/compnents/ico/favicon.png">

                Houpix

                                            Welcome Roger, busy?

 12 new comments

 6 new events

 2 sales reports

Sales: $800

Users: 1267

                        notifications 4

Hey, I wondered if you could help me as I can't log on to my account. Thanks

 Stan Smith 2 hours ago

New calendar event: 'Greg's Birthday Party' in 2 days time at 6pm

Sales of 'Product X' from 2013 Q3 are up 15% while others are up 2%

An error has occurred. The cron needs your attention

                    <form class="nav-search" action="">
                        <input type="text">
                    </form>

                Dashboard

                UI界面

元素

组件

排版

网格

Icon图标

                表单元素

表单组件

表单提示

表单编辑器

数据表格

                地图

Google地图

矢量地图

统计

日历

相册

                其他页面

登录

搜索结果

购物清单

空白页

价目单

404页

500页

                 Icon图标

                     13/08/13

Theme Icons

Font Awesome361 Icons

2016 Houpix All rights reserved


text:
layout: default
title: URI partial modifiers
---

Query modifiers
=====

The following modifiers update and normalize the URI query component.

Because each modification is done after parsing and building, the
resulting query string may update the component character encoding. These changes are expected because of
the rules governing parsing and building query string.

## UriModifier::sortQuery

Sorts the query according to its key values. The sorting rules are the same uses by WHATWG `URLSearchParams::sort` method.

~~~php
$uriString = "http://example.com/?kingkong=toto&foo=bar%20baz&kingkong=ape";
$uri = Http::createFromString($uriString);
$newUri = UriModifier::sortQuery($uri);

echo $uri->getQuery();    //display "kingkong=toto&foo=bar%20baz&kingkong=ape"
echo $newUri->getQuery(); //display "kingkong=toto&kingkong=ape&foo=bar%20baz"
~~~

## UriModifier::mergeQuery

Merges a submitted query string to the URI object to be modified. When merging two query strings with the same key value the submitted query string value takes precedence over the URI query string value.

~~~php
$uriString = "http://example.com/test.php?kingkong=toto&foo=bar+baz#doc3";
$uri = Http::createFromString($uriString);
$newUri = UriModifier::mergeQuery($uri, 'kingkong=godzilla&toto');

echo $uri->getQuery();    //display "kingkong=toto&foo=bar+baz"
echo $newUri->getQuery(); //display "kingkong=godzilla&foo=bar%20baz&toto"
~~~

## UriModifier::appendQuery

Appends a submitted query string to the URI object to be modified. When appending two query strings with the same key value the submitted query string value is added to the return query string without modifying the URI query string value.

~~~php
$uriString = "http://example.com/test.php?kingkong=toto&foo=bar+baz#doc3";
$uri = Http::createFromString($uriString);
$newUri = UriModifier::appendQuery($uri, 'kingkong=godzilla&toto');

echo $uri->getQuery();    //display "kingkong=toto&foo=bar+baz"
echo $newUri->getQuery(); //display "kingkong=toto&kingkong=godzilla&foo=bar%20baz&toto"
~~~

## UriModifier::removePairs

Removes query pairs from the current URI query string by providing the pairs key.

~~~php
$uriString = "http://example.com/test.php?kingkong=toto&foo=bar+baz&bar=baz#doc3")
$uri = Http::createFromString($uriString);
$newUri = UriModifier::removePairs($uri, 'foo', 'bar');

echo $uri->getQuery();    //display "kingkong=toto&foo=bar+baz&bar=baz"
echo $newUri->getQuery(); //display "kingkong=toto"
~~~

## UriModifier::removeParams

Removes query params from the current URI query string by providing the param name. The removal preserves mangled key params.

~~~php
$uriString = "http://example.com/test.php?kingkong=toto&fo.o=bar&fo_o=bar";
$uri = Http::createFromString($uriString);
$newUri = UriModifier::removeParams($uri, 'fo.o');

echo $uri->getQuery();    //display "kingkong=toto&fo.o=bar&fo_o=bar"
echo $newUri->getQuery(); //display "kingkong=toto&fo_o=bar"
~~~


text: assert(!isFinite(Math.min()));


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

    Copyright (C) [2013] [The FURTHeR Project]

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

            http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

-->
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	">

	<!-- =========================================== -->
	<!-- Properties files -->
	<!-- =========================================== -->

	<!-- Property file locations -->
	<context:property-placeholder location="classpath:*.properties" />

	<!-- =========================================== -->
	<!-- Annotation configuration -->
	<!-- =========================================== -->

	<context:annotation-config />
	<!-- <context:spring-configured /> -->
	<!-- <context:load-time-weaver /> -->

	<context:component-scan base-package="edu.utah.further.fqe.impl.service.query">
		<context:exclude-filter type="regex"
			expression=".*AggregationServiceImpl" />
		<context:exclude-filter type="regex"
			expression=".*QueryContext.*ServiceImpl" />
		<context:exclude-filter type="regex"
			expression=".*MockImpl" />

	</context:component-scan>

</beans>


text:
/*!
 * \file   atomic/detail/casts.hpp
 *
 * This header defines \c union_cast and \c memcpy_cast used to convert between storage and value types
 */

#ifndef BOOST_ATOMIC_DETAIL_CASTS_HPP_INCLUDED_
#define BOOST_ATOMIC_DETAIL_CASTS_HPP_INCLUDED_

#include <cstring>
#include <boost/atomic/detail/config.hpp>

#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif

namespace boost {
namespace atomics {
namespace detail {

template< typename To, typename From >
BOOST_FORCEINLINE To union_cast(From const& from) BOOST_NOEXCEPT
{
    union
    {
        To as_to;
        From as_from;
    }
    caster = {};
    caster.as_from = from;
    return caster.as_to;
}

template< typename To, typename From >
BOOST_FORCEINLINE To memcpy_cast(From const& from) BOOST_NOEXCEPT
{
    struct
    {
        To to;
    }
    value = {};
    std::memcpy
    (
        &reinterpret_cast< char& >(value.to),
        &reinterpret_cast< const char& >(from),
        (sizeof(From) < sizeof(To) ? sizeof(From) : sizeof(To))
    );
    return value.to;
}

} // namespace detail
} // namespace atomics
} // namespace boost

#endif // BOOST_ATOMIC_DETAIL_CASTS_HPP_INCLUDED_


text:
package org.fluentjava.iwant.eclipsesettings;

public class OrgJetbrainsKotlinCorePrefs {

	public static OrgJetbrainsKotlinCorePrefs withDefaultValues() {
		return new OrgJetbrainsKotlinCorePrefs();
	}

	public String asFileContent() {
		StringBuilder b = new StringBuilder();
		b.append("codeStyle/codeStyleId=KOTLIN_OFFICIAL\n");
		b.append("codeStyle/globalsOverridden=true\n");
		b.append("eclipse.preferences.version=1\n");
		b.append("globalsOverridden=true\n");
		return b.toString();
	}

}


text:
<?php

namespace Birgit\Core\Task\Type\Host;

use Birgit\Core\Task\Type\TaskType;
use Birgit\Component\Task\Queue\Context\TaskQueueContextInterface;
use Birgit\Component\Task\Model\Task\Task;

/**
 * Host - Delete Task Type
 */
class HostDeleteTaskType extends TaskType
{
    /**
     * {@inheritdoc}
     */
    public function getAlias()
    {
        return 'host_delete';
    }

    /**
     * {@inheritdoc}
     */
    public function run(Task $task, TaskQueueContextInterface $context)
    {
    }
}


text:
<?php

namespace Gentry\Tests;

use Gentry\Test;
use Gentry\Demo;
use stdClass;
use ReflectionFunction;

/**
 * Basic test running
 */
class Basic
{
    /**
     * Test::run should successfully run a test, pipe the result and catch
     * trimmed output
     */
    public function testClass(Test $test)
    {
        $target = new stdClass;
        $target->test = true;
        $reflection = new ReflectionFunction(
            /**
             * Test should be true
             */
            function (stdClass &$test = null) use ($target) {
                $test = $target;
                yield assert($test->test);
            }
        );
        $test->__gentryConstruct($target, $reflection);
        echo "       ";
        $passed = 0;
        $failed = 0;
        $messages = [];
        yield assert(is_array($test->run($passed, $failed, $messages)));
    }

    /**
     * 'test' should return true {?}, and 'foo' should contain "bar"
     */
    public function testMultiple(Demo\Test $test)
    {
        yield assert($test->test());
        yield assert($test->foo == 'bar');
    }

    /**
     * aStaticMethod should be tested statically
     */
    public function statically(Demo\Test $test = null)
    {
        yield assert($test::aStaticMethod());
    }
}


text:
package org.apache.camel.component.jms;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.jms.ConnectionFactory;

import org.apache.camel.CamelContext;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.apache.camel.util.concurrent.ThreadHelper;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestName;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static org.apache.camel.component.jms.JmsComponent.jmsComponentAutoAcknowledge;

/**
 *
 */
public class JmsDefaultTaskExecutorTypeTest extends CamelTestSupport {

    private static final Logger LOG = LoggerFactory.getLogger(JmsDefaultTaskExecutorTypeTest.class);
    @Rule public TestName name = new TestName();

    @Test
    public void testThreadPoolTaskExecutor() throws Exception {
        context.getRouteController().startRoute("threadPool");
        Long beforeThreadCount = currentThreadCount();
        getMockEndpoint("mock:result.threadPool").expectedMessageCount(1000);
        doSendMessages("foo.threadPool", 500, 5, DefaultTaskExecutorType.ThreadPool);
        Thread.sleep(100);
        doSendMessages("foo.threadPool", 500, 5, DefaultTaskExecutorType.ThreadPool);
        assertMockEndpointsSatisfied();
        Long numberThreadsCreated = currentThreadCount() - beforeThreadCount;
        LOG.info("Number of threads created, testThreadPoolTaskExecutor: " + numberThreadsCreated);
        assertTrue("Number of threads created should be equal or lower than "
                + "100 with ThreadPoolTaskExecutor", numberThreadsCreated <= 100);
    }

    @Test
    public void testSimpleAsyncTaskExecutor() throws Exception {
        context.getRouteController().startRoute("simpleAsync");
        Long beforeThreadCount = currentThreadCount();
        getMockEndpoint("mock:result.simpleAsync").expectedMessageCount(1000);
        doSendMessages("foo.simpleAsync", 500, 5, DefaultTaskExecutorType.SimpleAsync);
        Thread.sleep(100);
        doSendMessages("foo.simpleAsync", 500, 5, DefaultTaskExecutorType.SimpleAsync);
        assertMockEndpointsSatisfied();
        Long numberThreadsCreated = currentThreadCount() - beforeThreadCount;
        LOG.info("Number of threads created, testSimpleAsyncTaskExecutor: " + numberThreadsCreated);
        assertTrue("Number of threads created should be equal or higher than "
                + "800 with SimpleAsyncTaskExecutor", numberThreadsCreated >= 800);
    }

    @Test
    public void testDefaultTaskExecutor() throws Exception {
        context.getRouteController().startRoute("default");
        Long beforeThreadCount = currentThreadCount();
        getMockEndpoint("mock:result.default").expectedMessageCount(1000);
        doSendMessages("foo.default", 500, 5, null);
        Thread.sleep(100);
        doSendMessages("foo.default", 500, 5, null);
        assertMockEndpointsSatisfied();
        Long numberThreadsCreated = currentThreadCount() - beforeThreadCount;
        LOG.info("Number of threads created, testDefaultTaskExecutor: " + numberThreadsCreated);
        assertTrue("Number of threads created should be equal or higher than "
                + "800 with default behaviour", numberThreadsCreated >= 800);
    }

    @Test
    public void testDefaultTaskExecutorThreadPoolAtComponentConfig() throws Exception {
        // the default behaviour changes in this test, see createCamelContext method below
        // the behaviour is the same as with testThreadPoolTaskExecutor test method above
        context.getRouteController().startRoute("default");
        Long beforeThreadCount = currentThreadCount();
        getMockEndpoint("mock:result.default").expectedMessageCount(1000);
        doSendMessages("foo.default", 500, 5, DefaultTaskExecutorType.ThreadPool);
        Thread.sleep(100);
        doSendMessages("foo.default", 500, 5, DefaultTaskExecutorType.ThreadPool);
        assertMockEndpointsSatisfied();
        Long numberThreadsCreated = currentThreadCount() - beforeThreadCount;
        LOG.info("Number of threads created, testDefaultTaskExecutorThreadPoolAtComponentConfig: " + numberThreadsCreated);
        assertTrue("Number of threads created should be equal or lower than "
                + "100 with ThreadPoolTaskExecutor as a component default", numberThreadsCreated <= 100);
    }

    private Long currentThreadCount() throws NoSuchMethodException,
            IllegalAccessException, InvocationTargetException {
        Method m = ThreadHelper.class.getDeclaredMethod("nextThreadCounter", (Class<?>[]) null);
        m.setAccessible(true);
        Long nextThreadCount = (Long) m.invoke(null);
        return nextThreadCount;
    }

    @Override
    protected CamelContext createCamelContext() throws Exception {
        CamelContext camelContext = super.createCamelContext();
        ConnectionFactory connectionFactory = CamelJmsTestHelper.createConnectionFactory();
        JmsComponent jmsComponent = jmsComponentAutoAcknowledge(connectionFactory);
        jmsComponent.getConfiguration().setMaxMessagesPerTask(1);
        jmsComponent.getConfiguration().setIdleTaskExecutionLimit(1);
        jmsComponent.getConfiguration().setConcurrentConsumers(3);
        jmsComponent.getConfiguration().setMaxConcurrentConsumers(10);
        jmsComponent.getConfiguration().setReceiveTimeout(50);
        if ("testDefaultTaskExecutorThreadPoolAtComponentConfig".equals(getTestMethodName())) {
            jmsComponent.getConfiguration().setDefaultTaskExecutorType(DefaultTaskExecutorType.ThreadPool);
        }
        camelContext.addComponent("activemq", jmsComponent);
        return camelContext;
    }

    private void doSendMessages(final String queueName, int messages, int poolSize,
            final DefaultTaskExecutorType defaultTaskExecutorType) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(poolSize);
        final CountDownLatch latch = new CountDownLatch(messages);
        for (int i = 0; i < messages; i++) {
            final int index = i;
            executor.submit(() -> {
                String options = defaultTaskExecutorType == null ? "" : "?defaultTaskExecutorType="
                        + defaultTaskExecutorType.toString();
                template.requestBody("activemq:queue:" + queueName + options, "Message " + index);
                latch.countDown();
                return null;
            });
        }
        latch.await();
        executor.shutdown();
    }

    @Override
    protected RouteBuilder createRouteBuilder() throws Exception {
        return new RouteBuilder() {
            @Override
            public void configure() throws Exception {
                from("activemq:queue:foo.simpleAsync?defaultTaskExecutorType=SimpleAsync").routeId("simpleAsync").noAutoStartup()
                    .to("mock:result.simpleAsync")
                    .setBody(constant("Reply"));

                from("activemq:queue:foo.threadPool?defaultTaskExecutorType=ThreadPool").routeId("threadPool").noAutoStartup()
                    .to("mock:result.threadPool")
                    .setBody(constant("Reply"));

                from("activemq:queue:foo.default").routeId("default").noAutoStartup()
                    .to("mock:result.default")
                    .setBody(constant("Reply"));
            }
        };
    }
}


text:
package io.github.emanual.app.utils;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;

public class _ {
    /**
     * 判断是否是url
     *
     * @param link
     * @return
     */
    public static boolean isURL(String link) {
        return link.startsWith("http") || link.startsWith("https");
    }

    /**
     * 是否是数字
     *
     * @param s
     * @return
     */
    public static boolean isNumber(String s) {
        try {
            Double.parseDouble(s);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 合并url
     *
     * @param baseUrl
     * @param strs
     * @return
     */
    public static String urlJoin(String baseUrl, String... strs) {
        StringBuilder sb = new StringBuilder(baseUrl);
        for (int i = 0; i < strs.length; i++) {
            try {
                sb.append("/").append(URLEncoder.encode(strs[i], "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        return sb.toString();
    }

    /**
     * 对url进行编码
     *
     * @param url
     * @return
     */
    public static String encodeURL(String url) {
        try {
            url = URLEncoder.encode(url, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return url;
    }

    /**
     * 检测文件是否存在
     * @param path
     * @return
     */
    public static boolean exists(String path) {
        File f = new File(path);
        return f.exists();
    }
    /**
     * 读文件
     */
    public static String readFile(String path){
        return readFile(new File(path));
    }

    /**
     * 读文件
     */
    public static String readFile(File file) {
        try {
            return readFile(new FileInputStream(file));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 读文件
     */
    public static String readFile(InputStream inputStream) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        byte buf[] = new byte[1024];
        int len;
        try {
            while ((len = inputStream.read(buf)) != -1) {
                outputStream.write(buf, 0, len);
            }
            outputStream.close();
            inputStream.close();

        } catch (IOException e) {
        }
        return outputStream.toString();
    }

}


text:
void generate_bytecode(Node* program, std::string outfilename);
#endif


text:
declare module "sdk/tabs" {
    export function on(eventName: string, listener: (e: any) => void): void // part of event emitter. Figure out a way to share that across different modules
    export var activeTab : SdkTab
}

interface SdkTab{
    id: number
}


text:
/* Standard C-native includes  */
#include <stdlib.h>
#include <string.h>

/* XDC/BIOS includes */
//#include <xdc/std.h>
//#include <xdc/runtime/IHeap.h>
//#include <xdc/runtime/System.h>
//#include <xdc/runtime/Memory.h>
//#include <xdc/runtime/Error.h>

// BEGIN AARON removed because no ti/bios
//#include <ti/sysbios/BIOS.h>
//#include <ti/sysbios/hal/Hwi.h>
//#include <ti/sysbios/knl/Task.h>
//#include <ti/sysbios/knl/Semaphore.h>
//#include <ti/sysbios/heaps/HeapBuf.h>
//#include <ti/sysbios/heaps/HeapMem.h>
// END AARON

//#include <xdc/cfg/global.h>

/* CSL CHIP, SEM Functional layer includes */
#include <ti/csl/csl_chip.h>
#include <ti/csl/csl_semAux.h>

/* CSL Cache module includes */
#include <ti/csl/csl_cacheAux.h>
/* CSL XMC module includes */
#include <ti/csl/csl_xmcAux.h>

/**********************************************************************
 ****************************** Defines *******************************
 **********************************************************************/

#define     MAX_NUM_CORES       8

/* Hardware Semaphore to synchronize access from
 * multiple applications (PA applications and non-PASS applications)
 * across different cores to the QMSS library.
 */
#define     QMSS_HW_SEM         3

/* Hardware Semaphore to synchronize access from
 * multiple applications (PASS applications and non-PASS applications)
 * across different cores to the CPPI library.
 */
#define     CPPI_HW_SEM         4

/* Hardware Semaphore to synchronize access from
 * multiple applications (PASS applications and non-PASS applications)
 * across different cores to the PA library.
 */
#define     PA_HW_SEM           5

#undef L2_CACHE
#ifdef L2_CACHE
    /* Invalidate L2 cache. This should invalidate L1D as well.
     * Wait until operation is complete. */
#define SYS_CACHE_INV(addr, size, code)    CACHE_invL2 (addr, size, code)

    /* Writeback L2 cache. This should Writeback L1D as well.
     * Wait until operation is complete. */
#define SYS_CACHE_WB(addr, size, code)     CACHE_wbL2 (addr, size, code)

#else
    /* Invalidate L1D cache and wait until operation is complete.
     * Use this approach if L2 cache is not enabled */
#define SYS_CACHE_INV(addr, size, code)    CACHE_invL1d (addr, size, code)
    /* Writeback L1D cache and wait until operation is complete.
     * Use this approach if L2 cache is not enabled */
#define SYS_CACHE_WB(addr, size, code)     CACHE_wbL1d (addr, size, code)

#endif

/**********************************************************************
 ************************** Global Variables **************************
 **********************************************************************/
Uint32      cpswCppiMallocCounter   =   0;
Uint32      cpswCppiFreeCounter     =   0;
Uint32      cpswQmssMallocCounter   =   0;
Uint32      cpswQmssFreeCounter     =   0;

Uint32      coreKey [MAX_NUM_CORES];

/**********************************************************************
 *********************** CPPI OSAL Functions **************************
 **********************************************************************/

/**
 * ============================================================================
 *  @n@b Osal_cppiCsEnter
 *
 *  @b  brief
 *  @n  This API ensures multi-core and multi-threaded
 *      synchronization to the caller.
 *
 *      This is a BLOCKING API.
 *
 *      This API ensures multi-core synchronization between
 *      multiple processes trying to access CPPI shared
 *      library at the same time.
 *
 *  @param[in]
 *  @n  None
 *
 *  @return
 *  @n  Handle used to lock critical section
 * =============================================================================
 */
Ptr Osal_cppiCsEnter (void)
{
		// BEGIN AARON no os scheduler

    /* Get the hardware semaphore.
     *
     * Acquire Multi core CPPI synchronization lock
     */
    //while ((CSL_semAcquireDirect (CPPI_HW_SEM)) == 0);

    /* Disable all interrupts and OS scheduler.
     *
     * Acquire Multi threaded / process synchronization lock.
     */
    //coreKey [CSL_chipReadReg (CSL_CHIP_DNUM)] = Hwi_disable();

		// END AARON

    return NULL;
}

/**
 * ============================================================================
 *  @n@b Osal_cppiCsExit
 *
 *  @b  brief
 *  @n  This API needs to be called to exit a previously
 *      acquired critical section lock using @a Osal_cppiCsEnter ()
 *      API. It resets the multi-core and multi-threaded lock,
 *      enabling another process/core to grab CPPI access.
 *
 *  @param[in]  CsHandle
 *      Handle for unlocking critical section.
 *
 *  @return     None
 * =============================================================================
 */
void Osal_cppiCsExit (Ptr CsHandle)
{
		// BEGIN AARON no os scheduler

    /* Enable all interrupts and enables the OS scheduler back on.
     *
     * Release multi-threaded / multi-process lock on this core.
     */
    //Hwi_restore(coreKey [CSL_chipReadReg (CSL_CHIP_DNUM)]);

    /* Release the hardware semaphore
     *
     * Release multi-core lock.
     */
    //CSL_semReleaseSemaphore (CPPI_HW_SEM);

		// END AARON

    return;
}

/**
 * ============================================================================
 *  @n@b Osal_cppiMalloc
 *
 *  @b  brief
 *  @n  This API allocates a memory block of a given
 *      size specified by input parameter 'num_bytes'.
 *
 *      This API should allocate memory from shared memory if the test applications
 *      are to be run on multiple cores.
 *
 *  @param[in]  num_bytes
 *      Number of bytes to be allocated.
 *
 *  @return
 *      Allocated block address
 * =============================================================================
 */
Ptr Osal_cppiMalloc (Uint32 num_bytes)
{
    /* Increment the allocation counter. */
    cpswCppiMallocCounter++;

	/* Allocate memory.  */
	return malloc(num_bytes);
}

/**
 * ============================================================================
 *  @n@b Osal_cppiFree
 *
 *  @b  brief
 *  @n  This API frees and restores a given memory location
 *      pointer 'dataPtr' of size 'num_bytes' to its
 *      original heap location. Frees up memory allocated using
 *      @a Osal_cppiMalloc ()
 *
 *  @param[in]  dataPtr
 *      Pointer to the memory block to be cleaned up.
 *
 *  @param[in]  num_bytes
 *      Size of the memory block to be cleaned up.
 *
 *  @return
 *      Not Applicable
 * =============================================================================
 */
void Osal_cppiFree (Ptr dataPtr, Uint32 num_bytes)
{
    /* Increment the free counter. */
    cpswCppiFreeCounter++;

    /* Free up the memory */
    if (dataPtr)
    {
        /* Convert the global address to local address since
         * thats what the heap understands.
         */
        free(dataPtr);
    }
}

/**
 *  @b Description
 *  @n
 *      The function is used to indicate that a block of memory is
 *      about to be accessed. If the memory block is cached then this
 *      indicates that the application would need to ensure that the
 *      cache is updated with the data from the actual memory.
 *
 *  @param[in]  blockPtr
 *       Address of the block which is to be invalidated
 *
 *  @param[in]  size
 *       Size of the block to be invalidated

 *  @retval
 *      Not Applicable
 */
void Osal_cppiBeginMemAccess (void *blockPtr, uint32_t size)
{
    /* Cleanup the prefetch buffer also. */
    CSL_XMC_invalidatePrefetchBuffer();

    SYS_CACHE_INV (blockPtr, size, CACHE_FENCE_WAIT);

    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");

    return;
}

/**
 *  @b Description
 *  @n
 *      The function is used to indicate that the block of memory has
 *      finished being accessed. If the memory block is cached then the
 *      application would need to ensure that the contents of the cache
 *      are updated immediately to the actual memory.
 *
 *  @param[in]  blockPtr
 *       Address of the block which is to be written back
 *
 *  @param[in]  size
 *       Size of the block to be written back

 *  @retval
 *      Not Applicable
 */
void Osal_cppiEndMemAccess (void *blockPtr, uint32_t size)
{
    SYS_CACHE_WB (blockPtr, size, CACHE_FENCE_WAIT);

    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");

    return;
}

/**********************************************************************
 *********************** QMSS OSAL Functions **************************
 **********************************************************************/

/**
 * ============================================================================
 *  @n@b Osal_qmssCsEnter
 *
 *  @b  brief
 *  @n  This API ensures multi-core and multi-threaded
 *      synchronization to the caller.
 *
 *      This is a BLOCKING API.
 *
 *      This API ensures multi-core synchronization between
 *      multiple processes trying to access QMSS shared
 *      library at the same time.
 *
 *  @param[in]  None
 *
 *  @return
 *      Handle used to lock critical section
 * =============================================================================
 */
Ptr Osal_qmssCsEnter (void)
{
		// BEGIN AARON no os scheduler

    /* Get the hardware semaphore.
     *
     * Acquire Multi core QMSS synchronization lock
     */
    //while ((CSL_semAcquireDirect (QMSS_HW_SEM)) == 0);

    /* Disable all interrupts and OS scheduler.
     *
     * Acquire Multi threaded / process synchronization lock.
     */
    //coreKey [CSL_chipReadReg (CSL_CHIP_DNUM)] = Hwi_disable();

		// END AARON

    return NULL;
}

/**
 * ============================================================================
 *  @n@b Osal_qmssCsExit
 *
 *  @b  brief
 *  @n  This API needs to be called to exit a previously
 *      acquired critical section lock using @a Osal_cpswQmssCsEnter ()
 *      API. It resets the multi-core and multi-threaded lock,
 *      enabling another process/core to grab QMSS access.
 *
 *  @param[in]  CsHandle
 *      Handle for unlocking critical section.
 *
 *  @return     None
 * =============================================================================
 */
void Osal_qmssCsExit (Ptr CsHandle)
{
		// BEGIN AARON no os scheduler

    /* Enable all interrupts and enables the OS scheduler back on.
     *
     * Release multi-threaded / multi-process lock on this core.
     */
    //Hwi_restore(coreKey [CSL_chipReadReg (CSL_CHIP_DNUM)]);

    /* Release the hardware semaphore
     *
     * Release multi-core lock.
     */
    //CSL_semReleaseSemaphore (QMSS_HW_SEM);

		// END AARON

    return;
}

/**
 * ============================================================================
 *  @n@b Osal_qmssMtCsEnter
 *
 *  @b  brief
 *  @n  This API ensures ONLY multi-threaded
 *      synchronization to the QMSS user.
 *
 *      This is a BLOCKING API.
 *
 *  @param[in] None
 *
 *  @return
 *       Handle used to lock critical section
 * =============================================================================
 */
Ptr Osal_qmssMtCsEnter (void)
{
    /* Disable all interrupts and OS scheduler.
     *
     * Acquire Multi threaded / process synchronization lock.
     */
    //coreKey [CSL_chipReadReg (CSL_CHIP_DNUM)] = Hwi_disable();

    return NULL;
}

/**
 * ============================================================================
 *  @n@b Osal_qmssMtCsExit
 *
 *  @b  brief
 *  @n  This API needs to be called to exit a previously
 *      acquired critical section lock using @a Osal_cpswQmssMtCsEnter ()
 *      API. It resets the multi-threaded lock, enabling another process
 *      on the current core to grab it.
 *
 *  @param[in]  CsHandle
 *      Handle for unlocking critical section.
 *
 *  @return     None
 * =============================================================================
 */
void Osal_qmssMtCsExit (Ptr CsHandle)
{
    /* Enable all interrupts and enables the OS scheduler back on.
     *
     * Release multi-threaded / multi-process lock on this core.
     */
    //Hwi_restore(key);

    return;
}

/**
 * ============================================================================
 *  @n@b Osal_qmssMalloc
 *
 *  @b  brief
 *  @n  This API allocates a memory block of a given
 *      size specified by input parameter 'num_bytes'.
 *
 *  @param[in]  num_bytes
 *      Number of bytes to be allocated.
 *
 *  @return
 *      Allocated block address
 * =============================================================================
 */
Ptr Osal_qmssMalloc (Uint32 num_bytes)
{
    /* Increment the allocation counter. */
    cpswQmssMallocCounter++;

	/* Allocate memory.  */
	return malloc(num_bytes);
}

/**
 * ============================================================================
 *  @n@b Osal_qmssFree
 *
 *  @b  brief
 *  @n  This API frees and restores a given memory location
 *      pointer 'dataPtr' of size 'num_bytes' to its
 *      original heap location. Frees up memory allocated using
 *      @a Osal_qmssMalloc ()
 *
 *  @param[in]  dataPtr
 *      Pointer to the memory block to be cleaned up.
 *
 *  @param[in]  num_bytes
 *      Size of the memory block to be cleaned up.
 *
 *  @return
 *      Not Applicable
 * =============================================================================
 */
void Osal_qmssFree (Ptr dataPtr, Uint32 num_bytes)
{
    /* Increment the free counter. */
    cpswQmssFreeCounter++;

    /* Free up the memory */
    if (dataPtr)
    {
        /* Convert the global address to local address since
         * thats what the heap understands.
         */
        free(dataPtr);
    }
}

/**
 *  @b Description
 *  @n
 *      The function is used to indicate that a block of memory is
 *      about to be accessed. If the memory block is cached then this
 *      indicates that the application would need to ensure that the
 *      cache is updated with the data from the actual memory.
 *
 *  @param[in]  blockPtr
 *       Address of the block which is to be invalidated
 *
 *  @param[in]  size
 *       Size of the block to be invalidated

 *  @retval
 *      Not Applicable
 */
void Osal_qmssBeginMemAccess (void *blockPtr, uint32_t size)
{
    /* Cleanup the prefetch buffer also. */
    CSL_XMC_invalidatePrefetchBuffer();

    SYS_CACHE_INV (blockPtr, size, CACHE_FENCE_WAIT);

    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");

    return;
}

/**
 *  @b Description
 *  @n
 *      The function is used to indicate that the block of memory has
 *      finished being accessed. If the memory block is cached then the
 *      application would need to ensure that the contents of the cache
 *      are updated immediately to the actual memory.
 *
 *  @param[in]  blockPtr
 *       Address of the block which is to be written back
 *
 *  @param[in]  size
 *       Size of the block to be written back

 *  @retval
 *      Not Applicable
 */
void Osal_qmssEndMemAccess (void *blockPtr, uint32_t size)
{
    SYS_CACHE_WB (blockPtr, size, CACHE_FENCE_WAIT);

    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");

    return;
}

/**********************************************************************
 *********************** PASS OSAL Functions **************************
 **********************************************************************/

/**
 * @brief  This macro is used to alert the application that the PA is
 *         going to access table memory. The application must ensure
 *         cache coherency
 *
 *
 * <b> Prototype: </b>
 *  The following is the C prototype for the expected OSAL API.
 *
 *  @verbatim
        void Osal_paBeginMemAccess (void* addr, uint32_t sizeWords)
    @endverbatim
 *
 *  <b> Parameters </b>
 *  @n  The address of the table to be accessed
 *  @n  The number of bytes in the table
 *
 *  @note PA will make nested calls to this function for memory access
 *        protection of different memory tables.
 */

void Osal_paBeginMemAccess (Ptr addr, Uint32 size)
{
    /* Cleanup the prefetch buffer also. */
    CSL_XMC_invalidatePrefetchBuffer();

    SYS_CACHE_INV (addr, size, CACHE_FENCE_WAIT);

    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
}

/**
 * @brief  This macro is used to alert the application that the PA
 *         has completed access to table memory. This call will always
 *         be made following a call to Osal_paBeginMemAccess and have
 *         the same parameters
 *
 * <b> Prototype: </b>
 *  The following is the C prototype for the expected OSAL API.
 *
 *  @verbatim
        void Osal_paEndMemAccess (void* addr, uint32_t sizeWords)
    @endverbatim
 *
 *  <b> Parameters </b>
 *  @n The address of the table to be accessed
 *  @n The number of bytes in the table
 *
 *  @note PA will make nested calls to this function for memory access
 *        protection of different memory tables.
 */

void Osal_paEndMemAccess (Ptr addr, Uint32 size)
{
    SYS_CACHE_WB (addr, size, CACHE_FENCE_WAIT);

    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
    asm   (" nop      4");
}

/**
 *  @b Description
 *  @n
 *      The function is used to enter a critical section.
 *      Function protects against
 *
 *      access from multiple threads on single core
 *      and
 *      access from multiple cores
 *
 *  @param[in]  key
 *      Key used to lock the critical section.
 *
 *  @retval
 *      Not Applicable
 */
void Osal_paMtCsEnter (uint32_t *key)
{
		// BEGIN AARON no os scheduler

    /* Get the hardware semaphore.
     *
     * Acquire Multi core PA synchronization lock
     */
     //while ((CSL_semAcquireDirect (PA_HW_SEM)) == 0);
     //*key = 0;

		 // END AARON
}

/**
 *  @b Description
 *  @n
 *      The function is used to exit a critical section
 *      protected using Osal_salldCsEnter() API.
 *
 *  @param[in]  key
 *      Key used to unlock the critical section.
 *
 *  @retval
 *      Not Applicable
 */
void Osal_paMtCsExit (uint32_t key)
{
		// BEGIN AARON no os scheduler

    /* Release the hardware semaphore */
    //CSL_semReleaseSemaphore (PA_HW_SEM);

		// END AARON
}


text:
<!DOCTYPE html>

    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <link rel="icon" href="http://getbootstrap.com/favicon.ico">
    <title>AngularJS and Firebase Web App</title>
    <link href="http://getbootstrap.com/dist/css/bootstrap.min.css" rel="stylesheet">

     <link href="https://getbootstrap.com/examples/blog/blog.css" rel="stylesheet">

                Home
                Add Post

        <form class="form-horizontal" ng-submit="AddPost()">
            <fieldset>

                <legend>Create Post</legend>

                    Title

                            <input id="txtTitle" name="txtTitle" ng-model="article.title" type="text" placeholder="placeholder" class="formcontrol input md"></input>

                    Post

                            <textarea class="form-control" id="txtPost" ng-model="article.post" name="txtPost"></textarea>

                            <input id="singlebutton" ng-Disabled="!article.title || !article.post" name="singlebutton" class="btn btn-primary" type="submit" value="Publish" />

            </fieldset>
        </form>

AngularJS & Firebase Blog App


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;

namespace Ploeh.Albedo.Refraction
{
    ///
    /// Creates <see cref="EventInfoElement" /> instances from a sequence of
    /// source objects.
    ///
    /// <typeparam name="T">The type of source objects.</typeparam>
    /// <seealso cref="Refract(IEnumerable{T})" />
    public class EventInfoElementRefraction<T> : IReflectionElementRefraction<T>
    {
        ///
        /// Creates <see cref="EventInfoElement" /> instances from a sequence
        /// of source objects.
        ///
        /// <param name="source">The source objects.</param>
        /// <returns>
        /// A sequence of <see cref="EventInfoElement" /> instances created
        /// from <paramref name="source" />.
        /// </returns>
        /// <exception cref="System.ArgumentNullException">
        /// <paramref name="source" /> is null.
        /// </exception>
        /// <remarks>
        /// <para>
        /// This method creates <see cref="EventInfoElement" /> instances from
        /// all matching elements in <paramref name="source" />. An element is
        /// matching if it's an <see cref="EventInfo" /> instance, in which
        /// case a corresponding EventInfoElement is created
        /// and returned.
        /// </para>
        /// </remarks>
        /// <seealso cref="IReflectionElementRefraction{T}" />
        public IEnumerable<IReflectionElement> Refract(IEnumerable<T> source)
        {
            return source
                .OfType<EventInfo>()
                .Select(ei => new EventInfoElement(ei))
                .Cast<IReflectionElement>();
        }
    }
}


text:
package net.novucs.ftop.manager;

import com.google.common.collect.Multimap;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import net.novucs.ftop.database.*;
import net.novucs.ftop.entity.*;

import java.sql.*;
import java.util.Map;
import java.util.Set;

public class DatabaseManager {

    private final HikariDataSource dataSource;
    private final IdentityCache identityCache;

    public static DatabaseManager create(HikariConfig hikariConfig) throws SQLException {
        return create(hikariConfig, new IdentityCache());
    }

    public static DatabaseManager create(HikariConfig hikariConfig, IdentityCache identityCache) throws SQLException {
        // Create the datasource.
        HikariDataSource dataSource = new HikariDataSource(hikariConfig);

        // Create the database manager.
        DatabaseManager manager = new DatabaseManager(dataSource, identityCache);

        // Initialize the database.
        Connection connection = dataSource.getConnection();
        manager.init(connection);
        connection.close();

        // Return the new database manager.
        return manager;
    }

    private DatabaseManager(HikariDataSource dataSource, IdentityCache identityCache) {
        this.dataSource = dataSource;
        this.identityCache = identityCache;
    }

    private void init(Connection connection) throws SQLException {
        PreparedStatement statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `world` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`name` VARCHAR(40) NOT NULL UNIQUE," +
                "PRIMARY KEY (`id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `chunk` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`world_id` INT NOT NULL," +
                "`x` INT NOT NULL," +
                "`z` INT NOT NULL," +
                "PRIMARY KEY (`id`)," +
                "FOREIGN KEY (`world_id`) REFERENCES world(`id`)," +
                "UNIQUE (`world_id`, `x`, `z`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `worth` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`name` VARCHAR (40) NOT NULL UNIQUE," +
                "PRIMARY KEY (`id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `chunk_worth` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`chunk_id` INT NOT NULL," +
                "`worth_id` INT NOT NULL," +
                "`worth` FLOAT NOT NULL," +
                "PRIMARY KEY (`id`)," +
                "FOREIGN KEY (`chunk_id`) REFERENCES chunk(`id`)," +
                "FOREIGN KEY (`worth_id`) REFERENCES worth(`id`)," +
                "UNIQUE(`chunk_id`, `worth_id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `material` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`name` VARCHAR(40) NOT NULL UNIQUE," +
                "PRIMARY KEY (`id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `chunk_material_count` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`chunk_id` INT NOT NULL," +
                "`material_id` INT NOT NULL," +
                "`count` INT NOT NULL," +
                "PRIMARY KEY (`id`)," +
                "FOREIGN KEY (`chunk_id`) REFERENCES chunk(`id`)," +
                "FOREIGN KEY (`material_id`) REFERENCES material(`id`)," +
                "UNIQUE (`chunk_id`, `material_id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `spawner` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`name` VARCHAR(40) NOT NULL UNIQUE," +
                "PRIMARY KEY (`id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `chunk_spawner_count` (" +
                "`id` INT NOT NULL AUTO_INCREMENT," +
                "`chunk_id` INT NOT NULL," +
                "`spawner_id` INT NOT NULL," +
                "`count` INT NOT NULL," +
                "PRIMARY KEY (`id`)," +
                "FOREIGN KEY (`chunk_id`) REFERENCES chunk(`id`)," +
                "FOREIGN KEY (`spawner_id`) REFERENCES spawner(`id`)," +
                "UNIQUE (`chunk_id`, `spawner_id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `block` (" +
                "`id` INT NOT NULL AUTO_INCREMENT, " +
                "`world_id` INT NOT NULL, " +
                "`x` INT NOT NULL, " +
                "`y` INT NOT NULL, " +
                "`z` INT NOT NULL, " +
                "PRIMARY KEY (`id`), " +
                "FOREIGN KEY (`world_id`) REFERENCES world(`id`), " +
                "UNIQUE (`world_id`, `x`, `y`, `z`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `sign` (" +
                "`id` INT NOT NULL AUTO_INCREMENT, " +
                "`block_id` INT NOT NULL UNIQUE, " +
                "`rank` INT NOT NULL, " +
                "PRIMARY KEY (`id`), " +
                "FOREIGN KEY (`block_id`) REFERENCES block(`id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `faction` (" +
                "`id` VARCHAR(40) NOT NULL, " +
                "`name` VARCHAR(40) NOT NULL, " +
                "`total_worth` FLOAT NOT NULL, " +
                "`total_spawners` INT NOT NULL, " +
                "PRIMARY KEY (`id`))");
        statement.executeUpdate();

        DatabaseMetaData metaData = connection.getMetaData();
        ResultSet resultSet = metaData.getIndexInfo(null, null, "faction", true, false);

        while (resultSet.next()) {
            String indexName = resultSet.getString("INDEX_NAME");

            if (indexName.equals("name")) {
                statement = connection.prepareStatement("DROP INDEX name ON faction");
                statement.executeUpdate();
            }
        }

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `faction_worth` (" +
                "`id` INT NOT NULL AUTO_INCREMENT, " +
                "`faction_id` VARCHAR(40) NOT NULL, " +
                "`worth_id` INT NOT NULL, " +
                "`worth` FLOAT NOT NULL, " +
                "PRIMARY KEY (`id`), " +
                "FOREIGN KEY (`faction_id`) REFERENCES faction(`id`), " +
                "FOREIGN KEY (`worth_id`) REFERENCES worth(`id`), " +
                "UNIQUE (`faction_id`, `worth_id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `faction_material_count` (" +
                "`id` INT NOT NULL AUTO_INCREMENT, " +
                "`faction_id` VARCHAR(40) NOT NULL, " +
                "`material_id` INT NOT NULL, " +
                "`count` INT NOT NULL, " +
                "PRIMARY KEY (`id`), " +
                "FOREIGN KEY (`faction_id`) REFERENCES faction(`id`), " +
                "FOREIGN KEY (`material_id`) REFERENCES material(`id`), " +
                "UNIQUE (`faction_id`, `material_id`))");
        statement.executeUpdate();

        statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS `faction_spawner_count` (" +
                "`id` INT NOT NULL AUTO_INCREMENT, " +
                "`faction_id` VARCHAR(40) NOT NULL, " +
                "`spawner_id` INT NOT NULL, " +
                "`count` INT NOT NULL, " +
                "PRIMARY KEY (`id`), " +
                "FOREIGN KEY (`faction_id`) REFERENCES faction(`id`), " +
                "FOREIGN KEY (`spawner_id`) REFERENCES spawner(`id`), " +
                "UNIQUE (`faction_id`, `spawner_id`))");
        statement.executeUpdate();
    }

    public IdentityCache getIdentityCache() {
        return identityCache;
    }

    public DataDump load() throws SQLException {
        Connection connection = dataSource.getConnection();

        NameLoader nameLoader = NameLoader.of(connection, identityCache);
        nameLoader.load();
        nameLoader.close();

        FactionLoader factionLoader = FactionLoader.of(connection, identityCache);
        factionLoader.load();
        factionLoader.close();

        ChunkLoader chunkLoader = ChunkLoader.of(connection, identityCache);
        Map<ChunkPos, ChunkWorth> chunks = chunkLoader.load();
        chunkLoader.close();

        SignLoader signLoader = SignLoader.of(connection, identityCache);
        Multimap<Integer, BlockPos> signs = signLoader.load();
        signLoader.close();

        connection.close();

        return new DataDump(chunks, signs);
    }

    public void save(Set<Map.Entry<ChunkPos, ChunkWorth>> chunks,
                     Set<FactionWorth> factions,
                     Set<String> deletedFactions,
                     Set<Map.Entry<BlockPos, Integer>> createdSigns,
                     Set<BlockPos> deletedSigns) throws SQLException {
        Connection connection = dataSource.getConnection();

        ChunkModel chunkModel = new ChunkModel(connection, identityCache);
        chunkModel.persist(chunks);

        FactionModel factionModel = new FactionModel(connection, identityCache);
        factionModel.persist(factions, deletedFactions);

        BlockModel blockModel = BlockModel.of(connection, identityCache);

        for (Map.Entry<BlockPos, Integer> entry : createdSigns) {
            blockModel.addBatch(entry.getKey());
        }

        blockModel.executeBatch();
        blockModel.close();

        SignModel signModel = SignModel.of(connection, identityCache);
        signModel.addBatch(createdSigns);
        signModel.addBatchDelete(deletedSigns);
        signModel.executeBatch();
        signModel.close();

        connection.close();
    }

    public void close() {
        dataSource.close();
    }

    public class DataDump {

        private final Map<ChunkPos, ChunkWorth> chunks;
        private final Multimap<Integer, BlockPos> signs;

        private DataDump(Map<ChunkPos, ChunkWorth> chunks, Multimap<Integer, BlockPos> signs) {
            this.chunks = chunks;
            this.signs = signs;
        }

        public Map<ChunkPos, ChunkWorth> getChunks() {
            return chunks;
        }

        public Multimap<Integer, BlockPos> getSigns() {
            return signs;
        }
    }
}