summary refs log blame commit diff stats
path: root/test/tc_ui.py
blob: fa2bdcac9c24b5e487c07df3ac2f3a00ad283c7f (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Copyright (C) 2009, 2010  Roman Zimbelmann <romanz@lavabit.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os.path
import sys
rangerpath = os.path.join(os.path.dirname(__file__), '..')
if sys.path[1] != rangerpath:
	sys.path[1:1] = [rangerpath]

import unittest
import curses

from ranger.gui import ui

from testlib import Fake, OK, raise_ok

ui.curses = Fake()

class Test(unittest.TestCase):
	def setUp(self):

		self.fm = Fake()
		self.ui = ui.UI(env=Fake(), fm=self.fm)

		def fakesetup():
			self.ui.widget = Fake()
			self.ui.add_child(self.ui.widget)
		self.ui.setup = fakesetup

		self.ui.initialize()

	def tearDown(self):
		self.ui.destroy()

	def test_passing(self):
		# Test whether certain method calls are passed to widgets
		widget = self.ui.widget

		widget.draw = raise_ok
		self.assertRaises(OK, self.ui.draw)
		widget.__clear__()

		widget.finalize = raise_ok
		self.assertRaises(OK, self.ui.finalize)
		widget.__clear__()

		widget.press = raise_ok
		random_key = 123
		self.assertRaises(OK, self.ui.handle_key, random_key)
		widget.__clear__()

		widget.destroy = raise_ok
		self.assertRaises(OK, self.ui.destroy)
		widget.__clear__()

if __name__ == '__main__':
	unittest.main()
>) void convert_ingredients_to_text(const recipe_ordinal r) { recipe& caller = get(Recipe, r); trace(9991, "transform") << "--- convert some ingredients to text in recipe " << caller.name << end(); // in recipes without named locations, 'stash' is still not extensible if (contains_numeric_locations(caller)) return; convert_ingredients_to_text(caller); } void convert_ingredients_to_text(recipe& caller) { vector<instruction> new_instructions; for (int i = 0; i < SIZE(caller.steps); ++i) { instruction& inst = caller.steps.at(i); // all these cases are getting hairy. how can we make this extensible? if (inst.name == "stash") { for (int j = 0; j < SIZE(inst.ingredients); ++j) { if (is_literal_text(inst.ingredients.at(j))) continue; ostringstream ingredient_name; ingredient_name << "stash_" << i << '_' << j << ":address:array:character"; convert_ingredient_to_text(inst.ingredients.at(j), new_instructions, ingredient_name.str()); } } else if (inst.name == "trace") { for (int j = /*skip*/2; j < SIZE(inst.ingredients); ++j) { if (is_literal_text(inst.ingredients.at(j))) continue; ostringstream ingredient_name; ingredient_name << "trace_" << i << '_' << j << ":address:array:character"; convert_ingredient_to_text(inst.ingredients.at(j), new_instructions, ingredient_name.str()); } } else if (inst.name_before_rewrite == "append") { // override only variants that try to append to a string // Beware: this hack restricts how much 'append' can be overridden. Any // new variants that match: // append _:text, ___ // will never ever get used. if (is_literal_text(inst.ingredients.at(0)) || is_mu_text(inst.ingredients.at(0))) { for (int j = /*skip base*/1; j < SIZE(inst.ingredients); ++j) { ostringstream ingredient_name; ingredient_name << "append_" << i << '_' << j << ":address:array:character"; convert_ingredient_to_text(inst.ingredients.at(j), new_instructions, ingredient_name.str()); } } } trace(9993, "transform") << to_string(inst) << end(); new_instructions.push_back(inst); } caller.steps.swap(new_instructions); } // add an instruction to convert reagent 'r' to text in list 'out', then // replace r with converted text void convert_ingredient_to_text(reagent& r, vector<instruction>& out, const string& tmp_var) { if (!r.type) return; // error; will be handled elsewhere if (is_mu_text(r)) return; // don't try to extend static arrays if (is_static_array(r)) return; instruction def; if (is_lookup_of_address_of_array(r)) { def.name = "array-to-text-line"; reagent/*copy*/ tmp = r; drop_one_lookup(tmp); def.ingredients.push_back(tmp); } else { def.name = "to-text-line"; def.ingredients.push_back(r); } def.products.push_back(reagent(tmp_var)); trace(9993, "transform") << to_string(def) << end(); out.push_back(def); r.clear(); // reclaim old memory r = reagent(tmp_var); } bool is_lookup_of_address_of_array(reagent/*copy*/ x) { if (x.type->atom) return false; if (x.type->left->name != "address") return false; if (!canonize_type(x)) return false; return is_mu_array(x); } bool is_static_array(const reagent& x) { // no canonize_type() return !x.type->atom && x.type->left->atom && x.type->left->name == "array"; } :(scenarios run) :(scenario append_other_types_to_text) def main [ local-scope n:num <- copy 11 c:character <- copy 111/o a:text <- append [abc], 10, n, c expected:text <- new [abc1011o] 10:bool/raw <- equal a, expected ] //: Make sure that the new system is strictly better than just the 'stash' //: primitive by itself. :(scenario rewrite_stash_continues_to_fall_back_to_default_implementation) # type without a to-text implementation container foo [ x:num y:num ] def main [ local-scope x:foo <- merge 34, 35 stash x ] +app: 34 35